feat: more privacy, better eslint and prettier config

.prettierrc

···
   "singleQuote": true,
   "tabWidth": 2,
   "useTabs": false,
-  "trailingComma": "es5",
+  "trailingComma": "all",
   "bracketSpacing": true,
+  "bracketSameLine": false,
   "arrowParens": "always",
   "printWidth": 100,
-  "endOfLine": "auto"
+  "endOfLine": "lf",
+  "quoteProps": "as-needed",
+  "singleAttributePerLine": true,
+  "embeddedLanguageFormatting": "auto",
+  "experimentalTernaries": false,
+  "overrides": [
+    {
+      "files": ["*.md", "*.mdx"],
+      "options": {
+        "printWidth": 80,
+        "proseWrap": "always"
+      }
+    },
+    {
+      "files": ["*.json", "*.jsonc"],
+      "options": {
+        "trailingComma": "none"
+      }
+    },
+    {
+      "files": ["*.yml", "*.yaml"],
+      "options": {
+        "tabWidth": 2,
+        "singleQuote": false
+      }
+    }
+  ]
 }

CODE_OF_CONDUCT.md

···
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our project and our community a harassment-free experience for everyone.
+We as members, contributors, and leaders pledge to make participation in our
+project and our community a harassment-free experience for everyone.
 
 ## Our Standards
 
···
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the maintainer at [e-mail].
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the maintainer at [e-mail].

README.md

···
 
 [![Node.js](https://img.shields.io/badge/node-%3E=16.9.0-green?logo=node.js)](https://nodejs.org/)
 
-A privacy-conscious, production-ready Discord user-installed bot with AI chat, reminders, and utility commands. Built with Node.js, Discord.js v14, PostgreSQL, and robust security best practices.
+A privacy-conscious, production-ready Discord user-installed bot with AI chat,
+reminders, and utility commands. Built with Node.js, Discord.js v14, PostgreSQL,
+and robust security best practices.
 
 ---
 
 ## Features
 
-- **AI Chat**: `/ai` command with custom API key support (OpenRouter, OpenAI, Grok)
+- **AI Chat**: `/ai` command with custom API key support (OpenRouter, OpenAI,
+  Grok)
 - **Reminders**: `/remind` command for scheduling reminders
-- **Utilities**: `/weather`, `/wiki`, `/joke`, `/cat`, `/dog`, `/8ball`, `/whois`
+- **Utilities**: `/weather`, `/wiki`, `/joke`, `/cat`, `/dog`, `/8ball`,
+  `/whois`
 - **Ephemeral Replies** for sensitive commands
 - **Encrypted API Key Storage** (AES-256-GCM)
 - **Rate Limiting & Logging**
···
 
 - Use `/ai` for AI chat, with optional custom API key for private usage
 - Use `/remind` to schedule reminders
-- Use utility commands: `/weather`, `/wiki`, `/joke`, `/cat`, `/dog`, `/8ball`, `/whois`
+- Use utility commands: `/weather`, `/wiki`, `/joke`, `/cat`, `/dog`, `/8ball`,
+  `/whois`
 - Sensitive commands use ephemeral replies for privacy
 - Use `/ai use_custom_api:true` to set your own (encrypted) API key
 
···
 
 ## 🌐 Translations & Localization
 
-Aethel supports multiple languages! You can help improve or add new translations for the bot.
+Aethel supports multiple languages! You can help improve or add new translations
+for the bot.
 
 ### Supported Languages
 
-- English (en-US)
-  <a href="http://translate.aethel.xyz/engage/aethel/en/">
+- English (en-US) <a href="http://translate.aethel.xyz/engage/aethel/en/">
   <img src="http://translate.aethel.xyz/widgets/aethel/en/svg-badge.svg" alt="English translation status" />
   </a>
-- Spanish (es-ES)
-  <a href="http://translate.aethel.xyz/engage/aethel/es/">
+- Spanish (es-ES) <a href="http://translate.aethel.xyz/engage/aethel/es/">
   <img src="http://translate.aethel.xyz/widgets/aethel/es/svg-badge.svg" alt="Spanish translation status" />
   </a>
 - Spanish (Latin America) (es-419)
   <a href="http://translate.aethel.xyz/engage/aethel/es_419/">
   <img src="http://translate.aethel.xyz/widgets/aethel/es_419/svg-badge.svg" alt="Spanish (Latin America) translation status" />
   </a>
-- German (de-DE)
-  <a href="http://translate.aethel.xyz/engage/aethel/de/">
+- German (de-DE) <a href="http://translate.aethel.xyz/engage/aethel/de/">
   <img src="http://translate.aethel.xyz/widgets/aethel/de/svg-badge.svg" alt="German translation status" />
   </a>
-- French (fr-FR)
-  <a href="http://translate.aethel.xyz/engage/aethel/fr/">
+- French (fr-FR) <a href="http://translate.aethel.xyz/engage/aethel/fr/">
   <img src="http://translate.aethel.xyz/widgets/aethel/fr/svg-badge.svg" alt="French translation status" />
   </a>
 - Portuguese (Brazil) (pt-BR)
   <a href="http://translate.aethel.xyz/engage/aethel/pt_BR/">
   <img src="http://translate.aethel.xyz/widgets/aethel/pt_BR/svg-badge.svg" alt="Portuguese (Brazil) translation status" />
   </a>
-- Japanese (ja)
-  <a href="http://translate.aethel.xyz/engage/aethel/ja/">
+- Japanese (ja) <a href="http://translate.aethel.xyz/engage/aethel/ja/">
   <img src="http://translate.aethel.xyz/widgets/aethel/ja/svg-badge.svg" alt="Japanese translation status" />
   </a>
 
 ### Contribute a Translation
 
-We use [Weblate](https://translate.aethel.xyz/projects/aethel/) for collaborative translation. Anyone can contribute:
+We use [Weblate](https://translate.aethel.xyz/projects/aethel/) for
+collaborative translation. Anyone can contribute:
 
-- Visit the [Aethel Weblate project](https://translate.aethel.xyz/projects/aethel/)
+- Visit the
+  [Aethel Weblate project](https://translate.aethel.xyz/projects/aethel/)
 - Sign in or register (free)
 - Pick your language and start translating or reviewing existing translations
 

SECURITY.md

···
 
 ## Reporting a Vulnerability
 
-We take security vulnerabilities seriously. If you discover a security vulnerability in Aethel, please report it responsibly.
+We take security vulnerabilities seriously. If you discover a security
+vulnerability in Aethel, please report it responsibly.
 
 ### How to Report
 
···
 ### What to Expect
 
 - **Acknowledgment**: We will acknowledge receipt of your report within 48 hours
-- **Initial Assessment**: We will provide an initial assessment within 5 business days
-- **Updates**: We will keep you informed of our progress throughout the investigation
+- **Initial Assessment**: We will provide an initial assessment within 5
+  business days
+- **Updates**: We will keep you informed of our progress throughout the
+  investigation
 - **Resolution**: We aim to resolve critical vulnerabilities within 30 days
 
 ### Responsible Disclosure
···
 
 - We will work with you to understand and resolve the issue
 - We will credit you for the discovery (unless you prefer to remain anonymous)
-- We ask that you do not publicly disclose the vulnerability until we have had a chance to address it
+- We ask that you do not publicly disclose the vulnerability until we have had a
+  chance to address it
 
 ## Security Measures
 
 ### Current Security Implementations
 
-- **SSRF Protection**: API endpoints are restricted to whitelisted hosts to prevent Server-Side Request Forgery attacks
+- **SSRF Protection**: API endpoints are restricted to whitelisted hosts to
+  prevent Server-Side Request Forgery attacks
 - **Input Validation**: All user inputs are validated and sanitized
 - **Encryption**: Sensitive data like API keys are encrypted before storage
 - **Authentication**: Secure token-based authentication for API access
···
 
 ### Allowed API Hosts
 
-For security reasons, custom API endpoints are restricted to the following trusted hosts:
+For security reasons, custom API endpoints are restricted to the following
+trusted hosts:
 
 - `api.openai.com`
 - `openrouter.ai`
···
 
 When contributing to or using Aethel:
 
-1. **Never commit secrets**: Do not include API keys, passwords, or other sensitive information in code
-2. **Use environment variables**: Store sensitive configuration in environment variables
+1. **Never commit secrets**: Do not include API keys, passwords, or other
+   sensitive information in code
+2. **Use environment variables**: Store sensitive configuration in environment
+   variables
 3. **Validate inputs**: Always validate and sanitize user inputs
 4. **Follow least privilege**: Grant minimal necessary permissions
-5. **Keep dependencies updated**: Regularly update dependencies to patch known vulnerabilities
+5. **Keep dependencies updated**: Regularly update dependencies to patch known
+   vulnerabilities
 
 ## Security Audits
 
-We regularly review our codebase for security vulnerabilities and welcome security audits from the community.
+We regularly review our codebase for security vulnerabilities and welcome
+security audits from the community.
 
 ### Automated Security Checks
 
···
 
 ## Contact
 
-For security-related questions or concerns, please contact the project maintainers at [e-mail]
+For security-related questions or concerns, please contact the project
+maintainers at [e-mail]
 
 ---
 
-**Note**: This security policy is subject to change. Please check back regularly for updates.
+**Note**: This security policy is subject to change. Please check back regularly
+for updates.

eslint.config.mjs

···
-import js from "@eslint/js";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-import { defineConfig } from "eslint/config";
+import js from '@eslint/js';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
 
-
-export default defineConfig([
-  { 
-    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], 
-    plugins: { js }, 
-    extends: ["js/recommended"],
-    ignores: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**"]
+export default [
+  {
+    ignores: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/.next/**',
+      '**/coverage/**',
+      '**/*.min.js',
+      '**/logs/**',
+    ],
   },
-  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], languageOptions: { globals: globals.browser } },
+
+  js.configs.recommended,
   ...tseslint.configs.recommended,
+
   {
-    files: ["**/*.{ts,tsx}"],
-    ignores: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**"],
+    files: ['**/*.{js,mjs,cjs,ts,mts,cts,tsx}'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.es2022,
+      },
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
     rules: {
-      "@typescript-eslint/no-unused-vars": [
-        "error",
+      'no-console': 'off',
+      'no-debugger': 'error',
+      'no-alert': 'error',
+      'no-eval': 'error',
+      'no-implied-eval': 'error',
+
+      eqeqeq: ['error', 'always'],
+      curly: ['warn', 'multi-line'],
+      'no-else-return': 'warn',
+      'no-empty-function': 'warn',
+      'no-return-assign': 'error',
+      'no-throw-literal': 'error',
+
+      'no-unreachable': 'error',
+      'no-unused-expressions': 'error',
+      'no-useless-return': 'warn',
+
+      '@typescript-eslint/no-unused-vars': [
+        'error',
         {
-          "argsIgnorePattern": "^_",
-          "varsIgnorePattern": "^_",
-          "caughtErrorsIgnorePattern": "^_"
-        }
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+        },
       ],
-      "@typescript-eslint/no-explicit-any": "warn"
-    }
-  }
-]);
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-inferrable-types': 'warn',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      '@typescript-eslint/prefer-for-of': 'error',
+      '@typescript-eslint/consistent-type-imports': 'off',
+
+      'no-unused-vars': 'off',
+      'no-undef': 'off',
+      'no-redeclare': 'off',
+      '@typescript-eslint/no-redeclare': 'error',
+
+      'no-process-exit': 'off',
+      'no-new-require': 'error',
+      'no-path-concat': 'error',
+      'no-sync': 'warn',
+    },
+  },
+
+  {
+    files: ['**/*.config.{js,mjs,ts}', '**/eslint.config.mjs', '**/src/index.ts'],
+    rules: {
+      'no-console': 'off',
+      'no-process-exit': 'off',
+    },
+  },
+
+  {
+    files: ['**/*.test.{js,ts}', '**/*.spec.{js,ts}', '**/tests/**/*.{js,ts}'],
+    languageOptions: {
+      globals: {
+        ...globals.jest,
+        ...globals.node,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+    },
+  },
+];

src/commands/fun/8ball.ts

···
           'en-US': 'Your yes/no question for the magic 8-ball',
         })
         .setRequired(true)
-        .setMaxLength(200)
+        .setMaxLength(200),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
 
   execute: async (
     client: import('@/services/Client').default,
-    interaction: import('discord.js').ChatInputCommandInteraction
+    interaction: import('discord.js').ChatInputCommandInteraction,
   ) => {
     try {
       const cooldownCheck = await checkCooldown(
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
       const question = sanitizeInput(interaction.options.getString('question'));
       const translatedResponse = await client.getLocaleText(
         `commands.8ball.responces.${random(responses)}`,
-        interaction.locale
+        interaction.locale,
       );
       commandLogger.logFromInteraction(
         interaction,
-        `question: "${question?.substring(0, 50)}${question && question.length > 50 ? '...' : ''}"`
+        `question: "${question?.substring(0, 50)}${question && question.length > 50 ? '...' : ''}"`,
       );
       const [title, questionLabel, answerLabel] = await Promise.all([
         await client.getLocaleText('commands.8ball.says', interaction.locale),
···
         .setAccentColor(0x8b5cf6)
         .addTextDisplayComponents(new TextDisplayBuilder().setContent(`# 🔮 ${title}`))
         .addTextDisplayComponents(
-          new TextDisplayBuilder().setContent(`**${questionLabel}**\n> ${question}\n\n`)
+          new TextDisplayBuilder().setContent(`**${questionLabel}**\n> ${question}\n\n`),
         )
         .addTextDisplayComponents(new TextDisplayBuilder().setContent(`## ✨ ${answerLabel}`))
         .addTextDisplayComponents(new TextDisplayBuilder().setContent(translatedResponse));

src/commands/fun/cat.ts

···
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
                 ? await client.getLocaleText('reddit.from', interaction.locale, {
                     subreddit: catData.subreddit,
                   })
-                : ''
-            )
+                : '',
+            ),
           )
           .addMediaGalleryComponents(
-            new MediaGalleryBuilder().addItems(new MediaGalleryItemBuilder().setURL(catData.url))
+            new MediaGalleryBuilder().addItems(new MediaGalleryItemBuilder().setURL(catData.url)),
           )
           .addActionRowComponents(
             new ActionRowBuilder<ButtonBuilder>().addComponents(
···
                 .setStyle(ButtonStyle.Danger)
                 .setLabel(refreshLabel)
                 .setEmoji({ name: '🐱' })
-                .setCustomId('refresh_cat')
-            )
+                .setCustomId('refresh_cat'),
+            ),
           );
 
         try {
···
       const errorMsg = await client.getLocaleText('unexpectederror', interaction.locale);
 
       const errorContainer = new ContainerBuilder().addTextDisplayComponents(
-        new TextDisplayBuilder().setContent(errorMsg)
+        new TextDisplayBuilder().setContent(errorMsg),
       );
 
       if (!interaction.replied && !interaction.deferred) {

src/commands/fun/dog.ts

···
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
                 ? await client.getLocaleText('reddit.from', interaction.locale, {
                     subreddit: dogData.subreddit,
                   })
-                : ''
-            )
+                : '',
+            ),
           )
           .addMediaGalleryComponents(
-            new MediaGalleryBuilder().addItems(new MediaGalleryItemBuilder().setURL(dogData.url))
+            new MediaGalleryBuilder().addItems(new MediaGalleryItemBuilder().setURL(dogData.url)),
           )
           .addActionRowComponents(
             new ActionRowBuilder<MessageActionRowComponentBuilder>().addComponents(
···
                 .setStyle(ButtonStyle.Secondary)
                 .setLabel(refreshLabel)
                 .setEmoji({ name: '🐶' })
-                .setCustomId('refresh_dog')
-            )
+                .setCustomId('refresh_dog'),
+            ),
           );
 
         await interaction.editReply({
···
       const errorMsg = await client.getLocaleText('unexpectederror', interaction.locale);
 
       const errorContainer = new ContainerBuilder().addTextDisplayComponents(
-        new TextDisplayBuilder().setContent(errorMsg)
+        new TextDisplayBuilder().setContent(errorMsg),
       );
 
       if (!interaction.replied && !interaction.deferred) {

src/commands/fun/joke.ts

···
             value: 'programming',
             name_localizations: { 'es-ES': 'Programación', 'es-419': 'Programación' },
           },
-          { name: 'Dad', value: 'dad', name_localizations: { 'es-ES': 'Papá', 'es-419': 'Papá' } }
-        )
+          { name: 'Dad', value: 'dad', name_localizations: { 'es-ES': 'Papá', 'es-419': 'Papá' } },
+        ),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
         interaction.locale,
         {
           type: await client.getLocaleText(`commands.joke.type.${joke.type}`, interaction.locale),
-        }
+        },
       );
 
       const waitingFooter = await client.getLocaleText(
···
         interaction.locale,
         {
           seconds: 3,
-        }
+        },
       );
 
       const embed = new EmbedBuilder()
···
       setTimeout(async () => {
         try {
           embed.setDescription(
-            `${sanitizeInput(joke.setup)}\n\n*${sanitizeInput(joke.punchline)}*`
+            `${sanitizeInput(joke.setup)}\n\n*${sanitizeInput(joke.punchline)}*`,
           );
           embed.setFooter({ text: 'Ba dum tss! 🥁' });
           await interaction.editReply({ embeds: [embed] });

src/commands/fun/trivia.ts

···
 async function fetchTriviaQuestions(
   client: import('@/services/Client').default,
   locale: string,
-  playerCount: number
+  playerCount: number,
 ): Promise<TriviaQuestion[]> {
   try {
     const totalQuestions = Math.min(Math.max(playerCount * 2 + 1, 5), 50);
 
     const response = await dynamicFetch(
-      `https://opentdb.com/api.php?amount=${totalQuestions}&type=multiple`
+      `https://opentdb.com/api.php?amount=${totalQuestions}&type=multiple`,
     );
     const data: TriviaAPIResponse = await response.json();
 
···
 async function startTriviaGame(
   interaction: ChatInputCommandInteraction | ButtonInteraction,
   session: GameSession,
-  client: import('@/services/Client').default
+  client: import('@/services/Client').default,
 ) {
   try {
     session.questions = await fetchTriviaQuestions(
       client,
       interaction.locale,
-      session.players.size
+      session.players.size,
     );
     session.originalQuestionCount = session.questions.length;
     session.isActive = true;
···
   } catch {
     const errorMsg = await client.getLocaleText(
       'commands.trivia.messages.failed_start',
-      interaction.locale
+      interaction.locale,
     );
     await interaction.editReply({
       content: errorMsg,
···
 async function askQuestion(
   interaction: ChatInputCommandInteraction | ButtonInteraction,
   session: GameSession,
-  client: import('@/services/Client').default
+  client: import('@/services/Client').default,
 ) {
   if (session.currentQuestionIndex >= session.questions.length) {
     const sortedScores = Array.from(session.scores.entries()).sort(([, a], [, b]) => b - a);
···
 
         const tiedGameText = await client.getLocaleText(
           'commands.trivia.messages.tied_game',
-          interaction.locale
+          interaction.locale,
         );
         await interaction.editReply({
           content: tiedGameText || '🤝 Tied game! Keep going until someone scores!',
···
     '\n' +
     difficultyText.replace(
       '{difficulty}',
-      question.difficulty.charAt(0).toUpperCase() + question.difficulty.slice(1)
+      question.difficulty.charAt(0).toUpperCase() + question.difficulty.slice(1),
     ) +
     '\n\n' +
     questionText.replace('{question}', question.question);
···
 async function endGame(
   interaction: ChatInputCommandInteraction | ButtonInteraction,
   session: GameSession,
-  client: import('@/services/Client').default
+  client: import('@/services/Client').default,
 ) {
   const sortedScores = Array.from(session.scores.entries()).sort(([, a], [, b]) => b - a);
 
···
 
   execute: async (
     client: import('@/services/Client').default,
-    interaction: ChatInputCommandInteraction
+    interaction: ChatInputCommandInteraction,
   ) => {
     try {
       const channelId = interaction.channelId;
···
       if (gameManager.has(channelId)) {
         const errorMsg = await client.getLocaleText(
           'commands.trivia.messages.game_exists',
-          interaction.locale
+          interaction.locale,
         );
         return interaction.reply({
           content: errorMsg,
···
 
   handleButton: async (
     client: import('@/services/Client').default,
-    interaction: ButtonInteraction
+    interaction: ButtonInteraction,
   ) => {
     try {
       const channelId = interaction.channelId;
···
       if (!session) {
         const errorMsg = await client.getLocaleText(
           'commands.trivia.messages.no_active_game',
-          interaction.locale
+          interaction.locale,
         );
         return interaction.reply({
           content: errorMsg,
···
         if (!session.queueOpen) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.game_started',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,
···
         if (session.players.has(interaction.user.id)) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.already_joined',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,
···
         if (interaction.user.id !== session.gameCreator) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.only_creator_start',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,
···
         if (session.players.size < 1) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.need_players',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,
···
 
         const startingMsg = await client.getLocaleText(
           'commands.trivia.messages.starting_game',
-          interaction.locale
+          interaction.locale,
         );
         await interaction.update({
           content: startingMsg,
···
         if (interaction.user.id !== session.gameCreator) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.only_creator_cancel',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,
···
 
         const cancelMsg = await client.getLocaleText(
           'commands.trivia.messages.game_cancelled',
-          interaction.locale
+          interaction.locale,
         );
         await interaction.update({
           content: cancelMsg,
···
         if (!session.isActive) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.no_active_question',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: errorMsg,
···
         if (interaction.user.id !== session.currentPlayer) {
           const errorMsg = await client.getLocaleText(
             'commands.trivia.messages.not_your_turn',
-            interaction.locale
+            interaction.locale,
           );
           return interaction.reply({
             content: '❌ ' + errorMsg,

src/commands/info/help.ts

···
 
         .addMediaGalleryComponents(
           new MediaGalleryBuilder().addItems(
-            new MediaGalleryItemBuilder().setURL('https://aethel.xyz/aethel_banner_white.png')
-          )
+            new MediaGalleryItemBuilder().setURL('https://aethel.xyz/aethel_banner_white.png'),
+          ),
         )
         .addTextDisplayComponents(new TextDisplayBuilder().setContent(`# ${title || 'Aethel Bot'}`))
         .addTextDisplayComponents(
-          new TextDisplayBuilder().setContent(description || 'Get information about Aethel')
+          new TextDisplayBuilder().setContent(description || 'Get information about Aethel'),
         )
         .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
         .addTextDisplayComponents(
           new TextDisplayBuilder().setContent(
-            `\n## **${linksSocialText || 'Links & Social Media'}**`
-          )
+            `\n## **${linksSocialText || 'Links & Social Media'}**`,
+          ),
         )
         .addTextDisplayComponents(
           new TextDisplayBuilder().setContent(
-            '[Website](https://aethel.xyz) • [GitHub](https://github.com/aethel-labs/aethel) • [Bluesky](https://bsky.app/profile/aethel.xyz)'
-          )
+            '[Website](https://aethel.xyz) • [GitHub](https://github.com/aethel-labs/aethel) • [Bluesky](https://bsky.app/profile/aethel.xyz)',
+          ),
         )
         .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
         .addTextDisplayComponents(
-          new TextDisplayBuilder().setContent(`\n## **${featuresText || 'Features'}**`)
+          new TextDisplayBuilder().setContent(`\n## **${featuresText || 'Features'}**`),
         )
         .addTextDisplayComponents(
           new TextDisplayBuilder().setContent(
···
                 '**AI Integration** - Powered by OpenAI and other providers\n' +
                 '**Reminders** - Never forget important tasks\n' +
                 '**Utilities** - Weather, help, and productivity tools\n' +
-                '**Multi-language** - Supports multiple languages'
-          )
+                '**Multi-language** - Supports multiple languages',
+          ),
         )
 
         .addSeparatorComponents(
-          new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large).setDivider(true)
+          new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large).setDivider(true),
         )
         .addTextDisplayComponents(
           new TextDisplayBuilder().setContent(
-            `-# ${dashboardText || 'Dashboard available at https://aethel.xyz/login for To-Dos, Reminders and custom AI API key management'}`
-          )
+            `-# ${dashboardText || 'Dashboard available at https://aethel.xyz/login for To-Dos, Reminders and custom AI API key management'}`,
+          ),
         )
         .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
         .addActionRowComponents(
···
             new ButtonBuilder()
               .setStyle(ButtonStyle.Link)
               .setLabel(supportServerText || 'Support')
-              .setURL('https://discord.gg/63stE8pEaK')
-          )
+              .setURL('https://discord.gg/63stE8pEaK'),
+          ),
         );
 
       await interaction.reply({

src/commands/utilities/ai.ts

···
       const after = text[startIdx + url.length];
       if (before === '<' && after === '>') return url + (punctuation || '');
       return `<${url}>${punctuation || ''}`;
-    }
+    },
   );
 }
 
···
   client?: BotClient,
   model?: string,
   username?: string,
-  interaction?: ChatInputCommandInteraction
+  interaction?: ChatInputCommandInteraction,
 ): string {
   const now = new Date();
   const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
···
   let supportedCommands = '/help - Show all available commands and their usage';
   if (client?.commands) {
     const commandEntries = Array.from(client.commands.entries()).sort(([a], [b]) =>
-      a.localeCompare(b)
+      a.localeCompare(b),
     );
     supportedCommands = commandEntries
       .map(
-        ([name, command]) => `/${name} - ${command.data.description || 'No description available'}`
+        ([name, command]) => `/${name} - ${command.data.description || 'No description available'}`,
       )
       .join('\n');
   }
···
           detail?: 'low' | 'high' | 'auto';
         };
       }>,
-  systemPrompt: string
+  systemPrompt: string,
 ): ConversationMessage[] {
   let conversation = existingConversation.filter((msg) => msg.role !== 'system');
   conversation.push({ role: 'user', content: prompt });
···
   return conversation;
 }
 
-function splitResponseIntoChunks(response: string, maxLength: number = 2000): string[] {
+function splitResponseIntoChunks(response: string, maxLength = 2000): string[] {
   if (response.length <= maxLength) return [response];
 
   const chunks: string[] = [];
···
   userId: string,
   apiKey: string | null,
   model: string | null,
-  apiUrl: string | null
+  apiUrl: string | null,
 ): Promise<void> {
   if (apiKey === null) {
     await pool.query(
       `UPDATE users SET api_key_encrypted = NULL, custom_model = NULL, custom_api_url = NULL, updated_at = now() WHERE user_id = $1`,
-      [userId]
+      [userId],
     );
     logger.info(`Cleared API credentials for user ${userId}`);
   } else {
···
        VALUES ($1, $2, $3, $4, now())
        ON CONFLICT (user_id) DO UPDATE SET 
          api_key_encrypted = $2, custom_model = $3, custom_api_url = $4, updated_at = now()`,
-      [userId, encrypted, model?.trim() || null, apiUrl?.trim() || null]
+      [userId, encrypted, model?.trim() || null, apiUrl?.trim() || null],
     );
     logger.info(`Successfully saved encrypted API credentials for user ${userId}`);
   }
···
   }
 }
 
-async function incrementAndCheckDailyLimit(userId: string, limit: number = 20): Promise<boolean> {
+async function incrementAndCheckDailyLimit(userId: string, limit = 20): Promise<boolean> {
   const today = new Date().toISOString().slice(0, 10);
   const client = await pool.connect();
   try {
···
     const res = await client.query(
       `INSERT INTO ai_usage (user_id, usage_date, count) VALUES ($1, $2, 1)
        ON CONFLICT (user_id, usage_date) DO UPDATE SET count = ai_usage.count + 1 RETURNING count`,
-      [userId, today]
+      [userId, today],
     );
     await client.query('COMMIT');
     return res.rows[0].count <= limit;
···
 async function testApiKey(
   apiKey: string,
   model: string,
-  apiUrl: string
+  apiUrl: string,
 ): Promise<{ success: boolean; error?: string }> {
   try {
     const client = getOpenAIClient(apiKey, apiUrl);
···
 
 async function makeAIRequest(
   config: ReturnType<typeof getApiConfiguration>,
-  conversation: ConversationMessage[]
+  conversation: ConversationMessage[],
 ): Promise<AIResponse | null> {
   try {
     const client = getOpenAIClient(config.finalApiKey!, config.finalApiUrl);
···
 
 async function processAIRequest(
   client: BotClient,
-  interaction: ChatInputCommandInteraction
+  interaction: ChatInputCommandInteraction,
 ): Promise<void> {
   try {
     if (!interaction.deferred && !interaction.replied) {
···
     const prompt = interaction.options.getString('prompt')!;
     commandLogger.logFromInteraction(
       interaction,
-      `prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`
+      `prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
     );
 
     const { apiKey, model, apiUrl } = await getUserCredentials(interaction.user.id);
···
         if (!allowed) {
           await interaction.editReply(
             '❌ ' +
-              (await client.getLocaleText('commands.ai.process.dailylimit', interaction.locale))
+              (await client.getLocaleText('commands.ai.process.dailylimit', interaction.locale)),
           );
           return;
         }
       }
     } else if (!config.finalApiKey) {
       await interaction.editReply(
-        '❌ ' + (await client.getLocaleText('commands.ai.process.noapikey', interaction.locale))
+        '❌ ' + (await client.getLocaleText('commands.ai.process.noapikey', interaction.locale)),
       );
       return;
     }
···
       client,
       config.finalModel,
       interaction.user.tag,
-      interaction
+      interaction,
     );
     const conversation = buildConversation(conversationArray, prompt, systemPrompt);
 
···
 async function sendAIResponse(
   interaction: ChatInputCommandInteraction,
   aiResponse: AIResponse,
-  client: BotClient
+  client: BotClient,
 ): Promise<void> {
   let fullResponse = '';
 
···
           'es-419': 'Tu mensaje para la IA',
           'en-US': 'Your message to the AI',
         })
-        .setRequired(true)
+        .setRequired(true),
     )
     .addBooleanOption((option) =>
-      option.setName('use_custom_api').setDescription('Use your own API key?').setRequired(false)
+      option.setName('use_custom_api').setDescription('Use your own API key?').setRequired(false),
     )
     .addBooleanOption((option) =>
-      option.setName('reset').setDescription('Reset your AI chat history').setRequired(false)
+      option.setName('reset').setDescription('Reset your AI chat history').setRequired(false),
     ),
 
   async execute(client: BotClient, interaction: ChatInputCommandInteraction) {
···
           .setLabel(await client.getLocaleText('commands.ai.modal.apikey', interaction.locale))
           .setStyle(TextInputStyle.Short)
           .setPlaceholder(
-            await client.getLocaleText('commands.ai.modal.apikeyplaceholder', interaction.locale)
+            await client.getLocaleText('commands.ai.modal.apikeyplaceholder', interaction.locale),
           )
           .setRequired(true);
 
···
           .setLabel(await client.getLocaleText('commands.ai.modal.apiurl', interaction.locale))
           .setStyle(TextInputStyle.Short)
           .setPlaceholder(
-            await client.getLocaleText('commands.ai.modal.apiurlplaceholder', interaction.locale)
+            await client.getLocaleText('commands.ai.modal.apiurlplaceholder', interaction.locale),
           )
           .setRequired(true);
 
···
           .setLabel(await client.getLocaleText('commands.ai.modal.model', interaction.locale))
           .setStyle(TextInputStyle.Short)
           .setPlaceholder(
-            await client.getLocaleText('commands.ai.modal.modelplaceholder', interaction.locale)
+            await client.getLocaleText('commands.ai.modal.modelplaceholder', interaction.locale),
           )
           .setRequired(true);
 
         modal.addComponents(
           new ActionRowBuilder<TextInputBuilder>().addComponents(apiKeyInput),
           new ActionRowBuilder<TextInputBuilder>().addComponents(apiUrlInput),
-          new ActionRowBuilder<TextInputBuilder>().addComponents(modelInput)
+          new ActionRowBuilder<TextInputBuilder>().addComponents(modelInput),
         );
 
         await interaction.showModal(modal);
···
 
         if (!pendingRequest) {
           return interaction.editReply(
-            await client.getLocaleText('commands.ai.nopendingrequest', interaction.locale)
+            await client.getLocaleText('commands.ai.nopendingrequest', interaction.locale),
           );
         }
 
···
           parsedUrl = new URL(apiUrl);
         } catch {
           await interaction.editReply(
-            'API URL is invalid. Please use a supported API endpoint (OpenAI, OpenRouter, or Google Gemini).'
+            'API URL is invalid. Please use a supported API endpoint (OpenAI, OpenRouter, or Google Gemini).',
           );
           return;
         }
 
         if (!ALLOWED_API_HOSTS.includes(parsedUrl.hostname)) {
           await interaction.editReply(
-            'API URL not allowed. Please use a supported API endpoint (OpenAI, OpenRouter, or Google Gemini).'
+            'API URL not allowed. Please use a supported API endpoint (OpenAI, OpenRouter, or Google Gemini).',
           );
           return;
         }
 
         await interaction.editReply(
-          await client.getLocaleText('commands.ai.testing', interaction.locale)
+          await client.getLocaleText('commands.ai.testing', interaction.locale),
         );
         const testResult = await testApiKey(apiKey, model, apiUrl);
 
         if (!testResult.success) {
           const errorMessage = await client.getLocaleText(
             'commands.ai.testfailed',
-            interaction.locale
+            interaction.locale,
           );
           await interaction.editReply(
-            errorMessage.replace('{error}', testResult.error || 'Unknown error')
+            errorMessage.replace('{error}', testResult.error || 'Unknown error'),
           );
           return;
         }
 
         await setUserApiKey(userId, apiKey, model, apiUrl);
         await interaction.editReply(
-          await client.getLocaleText('commands.ai.testsuccess', interaction.locale)
+          await client.getLocaleText('commands.ai.testsuccess', interaction.locale),
         );
 
         if (!originalInteraction.deferred && !originalInteraction.replied) {

src/commands/utilities/cobalt.ts

···
           'es-419': 'La URL del video a descargar',
           'en-US': 'The URL of the video to download',
         })
-        .setRequired(true)
+        .setRequired(true),
     )
     .addStringOption((option) =>
       option
···
           { name: '1440p', value: '1440' },
           { name: '2160p (4K)', value: '2160' },
           { name: '4320p (8K)', value: '4320' },
-          { name: 'Max', value: 'max' }
-        )
+          { name: 'Max', value: 'max' },
+        ),
     )
     .addBooleanOption((option) =>
       option
···
           'es-ES': 'Descargar solo audio',
           'es-419': 'Descargar solo audio',
           'en-US': 'Download audio only',
-        })
+        }),
     )
     .addBooleanOption((option) =>
       option
···
           'es-ES': 'Silenciar audio',
           'es-419': 'Silenciar audio',
           'en-US': 'Mute audio',
-        })
+        }),
     )
     .addBooleanOption((option) =>
       option
···
           'es-ES': 'Descargar como GIF de Twitter',
           'es-419': 'Descargar como GIF de Twitter',
           'en-US': 'Download as Twitter GIF',
-        })
+        }),
     )
     .addBooleanOption((option) =>
       option
···
           'es-ES': 'Incluir audio original de TikTok',
           'es-419': 'Incluir audio original de TikTok',
           'en-US': 'Include TikTok original audio',
-        })
+        }),
     )
     .addStringOption((option) =>
       option
···
           { name: 'MP3', value: 'mp3' },
           { name: 'OGG', value: 'ogg' },
           { name: 'WAV', value: 'wav' },
-          { name: 'Best', value: 'best' }
-        )
+          { name: 'Best', value: 'best' },
+        ),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
 
         const buttonLabel = await client.getLocaleText(
           'commands.cobalt.button_label',
-          interaction.locale
+          interaction.locale,
         );
 
         const container = new ContainerBuilder()
···
             new MediaGalleryBuilder().addItems(
               new MediaGalleryItemBuilder()
                 .setDescription(data.filename || 'Downloaded media')
-                .setURL(downloadUrl)
-            )
+                .setURL(downloadUrl),
+            ),
           )
 
           .addSectionComponents(
             new SectionBuilder()
               .addTextDisplayComponents((textDisplay) =>
-                textDisplay.setContent(`-# Took: ${processingTime}s`)
+                textDisplay.setContent(`-# Took: ${processingTime}s`),
               )
               .setButtonAccessory((button) =>
-                button.setLabel(buttonLabel).setStyle(ButtonStyle.Link).setURL(downloadUrl)
-              )
+                button.setLabel(buttonLabel).setStyle(ButtonStyle.Link).setURL(downloadUrl),
+              ),
           );
 
         await interaction.editReply({
···
       } else if (data.status === 'error') {
         const unknownError = await client.getLocaleText(
           'commands.cobalt.unknown_error',
-          interaction.locale
+          interaction.locale,
         );
         let errorText = unknownError;
 
···
           interaction.locale,
           {
             error: errorText,
-          }
+          },
         );
 
         const errorContainer = new ContainerBuilder()
           .setAccentColor(0xff4757)
           .addSectionComponents(
             new SectionBuilder().addTextDisplayComponents((textDisplay) =>
-              textDisplay.setContent(`❌ ${errorMessage}`)
-            )
+              textDisplay.setContent(`❌ ${errorMessage}`),
+            ),
           );
 
         await interaction.editReply({
···
         const multipleItemsMessage = await client.getLocaleText(
           'commands.cobalt.multiple_items',
           interaction.locale,
-          { url }
+          { url },
         );
 
         const pickerContainer = new ContainerBuilder()
···
           .addSectionComponents(
             new SectionBuilder().addTextDisplayComponents((textDisplay) =>
               textDisplay.setContent(
-                `⚠️ ${multipleItemsMessage || 'Multiple items found. Please provide a more specific URL.'}`
-              )
-            )
+                `⚠️ ${multipleItemsMessage || 'Multiple items found. Please provide a more specific URL.'}`,
+              ),
+            ),
           );
 
         await interaction.editReply({
···
       } else if (data.status === 'local-processing') {
         const notSupportedMessage = await client.getLocaleText(
           'commands.cobalt.local_processing_not_supported',
-          interaction.locale
+          interaction.locale,
         );
 
         const processingContainer = new ContainerBuilder()
···
           .addSectionComponents(
             new SectionBuilder().addTextDisplayComponents((textDisplay) =>
               textDisplay.setContent(
-                `⚠️ ${notSupportedMessage || 'Local processing is not supported. Please try a different URL or option.'}`
-              )
-            )
+                `⚠️ ${notSupportedMessage || 'Local processing is not supported. Please try a different URL or option.'}`,
+              ),
+            ),
           );
 
         await interaction.editReply({
···
       } else {
         const unknownResponseMessage = await client.getLocaleText(
           'commands.cobalt.unknown_response',
-          interaction.locale
+          interaction.locale,
         );
 
         const unknownContainer = new ContainerBuilder()
           .setAccentColor(0xff4757)
           .addSectionComponents(
             new SectionBuilder().addTextDisplayComponents((textDisplay) =>
-              textDisplay.setContent(`❓ ${unknownResponseMessage}`)
-            )
+              textDisplay.setContent(`❓ ${unknownResponseMessage}`),
+            ),
           );
 
         await interaction.editReply({

src/commands/utilities/remind.ts

···
           ...reminder,
           created_at: reminder.created_at || new Date(reminder.expires_at),
         }),
-        timeUntilExpiry
+        timeUntilExpiry,
       );
 
       activeReminders.set(reminder.reminder_id, {
···
       });
 
       logger.debug(
-        `Scheduled reminder ${reminder.reminder_id} for ${new Date(expiresAt).toISOString()}`
+        `Scheduled reminder ${reminder.reminder_id} for ${new Date(expiresAt).toISOString()}`,
       );
     }
 
···
         ...reminder,
         created_at: reminder.created_at || new Date(),
       }),
-      timeUntilExpiry
+      timeUntilExpiry,
     );
 
     activeReminders.set(reminder.reminder_id, {
···
     });
 
     logger.info(
-      `Scheduled reminder ${reminder.reminder_id} for ${new Date(expiresAt).toISOString()}`
+      `Scheduled reminder ${reminder.reminder_id} for ${new Date(expiresAt).toISOString()}`,
     );
     return true;
   } catch (error) {
···
 
       const minutes = Math.floor(
         (new Date(reminder.expires_at).getTime() - new Date(reminder.created_at!).getTime()) /
-          (60 * 1000)
+          (60 * 1000),
       );
 
       const reminderTitle =
···
       const reminderDesc = await client.getLocaleText(
         'commands.remind.remindyou',
         reminder.locale,
-        { message: reminder.message }
+        { message: reminder.message },
       );
 
       const timeElapsedText =
···
             name: originalTimeText,
             value: `<t:${Math.floor(new Date(reminder.created_at!).getTime() / 1000)}:f>`,
             inline: true,
-          }
+          },
         )
         .setFooter({ text: `ID: ${reminder.reminder_id.slice(-6)}` })
         .setTimestamp();
···
         const originalMessageText = await client.getLocaleText('common.ogmessage', reminder.locale);
         const jumpToMessageText = await client.getLocaleText(
           'common.jumptomessage',
-          reminder.locale
+          reminder.locale,
         );
 
         reminderEmbed.addFields({
···
         {
           error,
           reminderId: reminder.reminder_id,
-        }
+        },
       );
     } finally {
       try {
···
       }
     }
   },
-  60 * 60 * 1000
+  60 * 60 * 1000,
 );
 
 function createCommandBuilder() {
···
           'es-ES': 'Cuándo recordarte (ej: 1h, 30m, 5h30m)',
           'es-419': 'Cuándo recordarte (ej: 1h, 30m, 5h30m)',
         })
-        .setRequired(true)
+        .setRequired(true),
     )
     .addStringOption((option) =>
       option
···
           'es-ES': 'Sobre qué quieres que te recuerde',
           'es-419': 'Sobre qué quieres que te recuerde',
         })
-        .setRequired(true)
+        .setRequired(true),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
 
       commandLogger.logFromInteraction(
         interaction,
-        `time: ${timeStr}, message: "${message.substring(0, 50)}${message.length > 50 ? '...' : ''}"`
+        `time: ${timeStr}, message: "${message.substring(0, 50)}${message.length > 50 ? '...' : ''}"`,
       );
 
       if (!validateTimeString(timeStr)) {
         logger.warn(`Invalid time format from ${userTag}: ${timeStr}`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.invalidformat',
-          interaction.locale
+          interaction.locale,
         );
         return await interaction.editReply({
           content: errorMsg,
···
         logger.warn(`Invalid message from ${userTag} - Length: ${message?.length}`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.providevalidchars',
-          interaction.locale
+          interaction.locale,
         );
         return await interaction.editReply({
           content: errorMsg,
···
         logger.warn(`Reminder time too short from ${userTag}: ${timeStr}`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.atleastoneminute',
-          interaction.locale
+          interaction.locale,
         );
         return await interaction.editReply({
           content: errorMsg,
···
         logger.warn(`Reminder time too long from ${userTag}: ${minutes} minutes`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.notlongerthanaday',
-          interaction.locale
+          interaction.locale,
         );
         return await interaction.editReply({
           content: errorMsg,
···
             ...reminderData,
             created_at: new Date(),
           }),
-          minutes * 60 * 1000
+          minutes * 60 * 1000,
         );
 
         activeReminders.set(reminderId, {
···
         const embed = new EmbedBuilder()
           .setColor(0xfaa0a0)
           .setTitle(
-            '⏰ ' + (await client.getLocaleText('commands.remind.reminderset', interaction.locale))
+            '⏰ ' + (await client.getLocaleText('commands.remind.reminderset', interaction.locale)),
           )
           .setDescription(
             await client.getLocaleText('commands.remind.iwillremindyou', interaction.locale, {
               message,
               time: formatTimeString(minutes),
-            })
+            }),
           )
           .addFields(
             {
···
                 (await client.getLocaleText('commands.remind.willtrigger', interaction.locale)),
               value: `<t:${Math.floor(expiresAt.getTime() / 1000)}:R>`,
               inline: true,
-            }
+            },
           )
           .setFooter({
             text: await client.getLocaleText('commands.remind.reminderid', interaction.locale, {
···
             userTag,
             expiresAt: expiresAt.toISOString(),
             messagePreview: message.length > 50 ? `${message.substring(0, 50)}...` : message,
-          }
+          },
         );
-        return;
       } catch (error) {
         if (error instanceof DatabaseError) {
           logger.error(`Database error saving reminder: ${error.message}`, {
···
           });
           const errorMessage = await client.getLocaleText(
             'commands.remind.errors.failedtosave',
-            interaction.locale
+            interaction.locale,
           );
           throw new Error(errorMessage);
         }
···
           messageId: message.id,
           channelId: message.channelId,
           guildId: message.guildId,
-        }
+        },
       );
 
       const modalTitle = await client.getLocaleText(
         'commands.remind.modal.setreminder',
-        interaction.locale
+        interaction.locale,
       );
       const timeLabel = await client.getLocaleText(
         'commands.remind.modal.whento',
-        interaction.locale
+        interaction.locale,
       );
       const modal = new ModalBuilder().setCustomId(modalId).setTitle(modalTitle);
 
···
           userId: user.id,
           userTag: user.tag,
           messageId: message?.id,
-        }
+        },
       );
 
       let errorMessage: string;
···
       } else {
         errorMessage = await client.getLocaleText(
           'commands.remind.errors.modalfailed',
-          interaction.locale
+          interaction.locale,
         );
         errorTitle = '❌ ' + (await client.getLocaleText('error', interaction.locale));
       }
···
         logger.warn(`No message info found for modal ID: ${modalId}`, { userId: user.id });
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.expired',
-          interaction.locale
+          interaction.locale,
         );
         return await modalInteraction.editReply({
           content: errorMsg,
···
         logger.warn(`Invalid time format from ${user.tag} in modal: ${timeStr}`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.invalidformat',
-          interaction.locale
+          interaction.locale,
         );
         return await modalInteraction.editReply({
           content: errorMsg,
···
         logger.warn(`Invalid time duration from ${user.tag} in modal: ${minutes} minutes`);
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.notlongerthanaday',
-          interaction.locale
+          interaction.locale,
         );
         return await modalInteraction.editReply({
           content: errorMsg,
···
           logger.error(`Database error saving reminder: ${error.message}`, { error });
           return await modalInteraction.editReply({
             content: error.userMessage,
-          });
-        } else {
-          logger.error(`Error saving reminder to database: ${(error as Error).message}`, { error });
-          const errorMsg = await client.getLocaleText(
-            'commands.remind.errors.failedtosave',
-            interaction.locale
-          );
-          return await modalInteraction.editReply({
-            content: errorMsg,
           });
         }
+        logger.error(`Error saving reminder to database: ${(error as Error).message}`, { error });
+        const errorMsg = await client.getLocaleText(
+          'commands.remind.errors.failedtosave',
+          interaction.locale,
+        );
+        return await modalInteraction.editReply({
+          content: errorMsg,
+        });
       }
 
       const timeoutId = setTimeout(
···
             message_url: messageInfo.url,
           },
         }),
-        minutes * 60 * 1000
+        minutes * 60 * 1000,
       );
 
       activeReminders.set(reminderId, {
···
 
       const jumpToMessageField = await client.getLocaleText(
         'common.jumptomessage',
-        interaction.locale
+        interaction.locale,
       );
 
       const embed = new EmbedBuilder()
         .setColor(0xfaa0a0)
         .setTitle(
-          '⏰ ' + (await client.getLocaleText('commands.remind.reminderset', interaction.locale))
+          '⏰ ' + (await client.getLocaleText('commands.remind.reminderset', interaction.locale)),
         )
         // .setTitle(reminderSetTitle)
         .setDescription(
           await client.getLocaleText('commands.remind.contextiwillremindyou', interaction.locale, {
             time: formatTimeString(minutes),
-          })
+          }),
         )
         // .setDescription(reminderSetDesc)
         .addFields(
···
             name: await client.getLocaleText('commands.remind.willtrigger', interaction.locale),
             value: `<t:${Math.floor(expiresAt.getTime() / 1000)}:R>`,
             inline: true,
-          }
+          },
         )
         .setFooter({
           text: await client.getLocaleText('commands.remind.reminderid', interaction.locale, {
···
         channelId: messageInfo.channelId,
         minutes,
       });
-      return;
     } catch (error) {
       logger.error(
         `Error handling reminder modal for ${user.tag} (${user.id}): ${(error as Error).message}`,
         {
           error,
           modalId,
-        }
+        },
       );
 
       try {
         const errorMsg = await client.getLocaleText(
           'commands.remind.errors.base',
-          interaction.locale
+          interaction.locale,
         );
         await modalInteraction.editReply({
           content: errorMsg,
···
       } catch (replyError) {
         logger.error('Failed to send error response to user:', { error: replyError });
       }
-      return;
     }
   },
 } as RemindCommandProps;

src/commands/utilities/time.ts

···
           'es-419': 'La ciudad (ej: Londres, Nueva York)',
         })
         .setRequired(true)
-        .setAutocomplete(true)
+        .setAutocomplete(true),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
         const flag = iso2ToDiscordFlag(match.iso2);
         const fieldDay = await client.getLocaleText(
           'commands.time.embed.field_day_of_week',
-          locale
+          locale,
         );
         const fieldTime = await client.getLocaleText('commands.time.embed.field_time', locale);
         const fieldDate = await client.getLocaleText('commands.time.embed.field_date', locale);
···
         const description = await client.getLocaleText(
           'commands.time.embed.multi_city_description',
           locale,
-          { city }
+          { city },
         );
         const fields = await Promise.all(
           shown.map(async (match) => {
···
             const flag = iso2ToDiscordFlag(match.iso2);
             const fieldDay = await client.getLocaleText(
               'commands.time.embed.field_day_of_week',
-              locale
+              locale,
             );
             const fieldTime = await client.getLocaleText('commands.time.embed.field_time', locale);
             const fieldDate = await client.getLocaleText('commands.time.embed.field_date', locale);
···
               value: `${fieldDay}: **${day}**\n${fieldTime}: **${time}**\n${fieldDate}: **${date}**`,
               inline: false,
             };
-          })
+          }),
         );
         const title = await client.getLocaleText('commands.time.embed.title_multi', locale, {
           city,
···
   async autocomplete(client, interaction: AutocompleteInteraction) {
     const focused = interaction.options.getFocused();
     const filtered = POPULAR_CITIES.filter((city) =>
-      city.toLowerCase().includes(focused.toLowerCase())
+      city.toLowerCase().includes(focused.toLowerCase()),
     ).slice(0, 25);
     await interaction.respond(filtered.map((city) => ({ name: city, value: city })));
   },

src/commands/utilities/todo.ts

···
   try {
     const { rows } = await pool.query(
       'SELECT item FROM todos WHERE user_id = $1 AND done = FALSE ORDER BY created_at ASC',
-      [userId]
+      [userId],
     );
     return rows.map((r) => r.item);
   } catch (error) {
···
   try {
     const { rows } = await pool.query(
       'SELECT item FROM todos WHERE user_id = $1 AND done = TRUE ORDER BY completed_at ASC',
-      [userId]
+      [userId],
     );
     return rows.map((r) => r.item);
   } catch (error) {
···
               'es-ES': 'La tarea a agregar',
               'es-419': 'La tarea a agregar',
             })
-            .setRequired(true)
-        )
+            .setRequired(true),
+        ),
     )
     .addSubcommand((sub) =>
       sub
···
               'es-419': 'Selecciona una tarea para marcar como hecha',
             })
             .setRequired(true)
-            .setAutocomplete(true)
-        )
+            .setAutocomplete(true),
+        ),
     )
     .addSubcommand((sub) =>
       sub
···
         .setDescriptionLocalizations({
           'es-ES': 'Ver tu lista de tareas',
           'es-419': 'Ver tu lista de tareas',
-        })
+        }),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
         try {
           const { rowCount } = await pool.query(
             'UPDATE todos SET done = TRUE, completed_at = NOW() WHERE user_id = $1 AND item = $2 AND done = FALSE',
-            [userId, item]
+            [userId, item],
           );
           if (rowCount === 0) {
             await interaction.reply({

src/commands/utilities/weather.ts

···
   const data = (await response.json()) as WeatherAPIResponse;
   if (!response.ok || data.cod !== 200) {
     const error = new Error(
-      (data as WeatherErrorResponse).message ?? 'Failed to fetch weather data'
+      (data as WeatherErrorResponse).message ?? 'Failed to fetch weather data',
     );
     throw error;
   }
···
           'en-US': 'City name (e.g., London, New York, Tokyo)',
         })
         .setRequired(true)
-        .setMaxLength(100)
+        .setMaxLength(100),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
           { name: weatherText, value: description, inline: true },
           { name: humidityText, value: `${data.main.humidity}%`, inline: true },
           { name: windText, value: `${windSpeed} ${windUnit}`, inline: true },
-          { name: pressureText, value: `${data.main.pressure} hPa`, inline: true }
+          { name: pressureText, value: `${data.main.pressure} hPa`, inline: true },
         )
         .setFooter({ text: footer + ' Open Weather' })
         .setTimestamp();

src/commands/utilities/whois.ts

···
 async function withRetry<T>(
   fn: () => Promise<T>,
   maxRetries = MAX_RETRIES,
-  baseDelay = 1000
+  baseDelay = 1000,
 ): Promise<T> {
   let lastError: any;
 
···
     }
 
     throw new Error(
-      'Could not retrieve WHOIS information. The domain may not exist or the WHOIS server may be temporarily unavailable.'
+      'Could not retrieve WHOIS information. The domain may not exist or the WHOIS server may be temporarily unavailable.',
     );
   };
 
···
     .setName('whois')
     .setDescription('Look up WHOIS information for a domain or IP address')
     .addStringOption((option) =>
-      option.setName('query').setDescription('Domain or IP address to look up').setRequired(true)
+      option.setName('query').setDescription('Domain or IP address to look up').setRequired(true),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
       cooldownManager,
       interaction.user.id,
       client,
-      interaction.locale
+      interaction.locale,
     );
     if (cooldownCheck.onCooldown) {
       return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
           .addTextDisplayComponents(new TextDisplayBuilder().setContent(`# 🔍 WHOIS Lookup`))
           .addTextDisplayComponents(new TextDisplayBuilder().setContent(`## ${sanitizedQuery}`))
           .addTextDisplayComponents(
-            new TextDisplayBuilder().setContent(formattedData || 'No WHOIS data available')
+            new TextDisplayBuilder().setContent(formattedData || 'No WHOIS data available'),
           ),
       ];
 

src/commands/utilities/wiki.ts

···
           'en-US': 'What do you want to search for?',
         })
         .setRequired(true)
-        .setMaxLength(200)
+        .setMaxLength(200),
     )
     .setContexts([
       InteractionContextType.BotDM,
···
         cooldownManager,
         interaction.user.id,
         client,
-        interaction.locale
+        interaction.locale,
       );
       if (cooldownCheck.onCooldown) {
         return interaction.reply(createCooldownResponse(cooldownCheck.message!));
···
         if (extract.length > MAX_EXTRACT_LENGTH) {
           const truncatedText = await client.getLocaleText(
             'commands.wiki.readmoreonwiki',
-            interaction.locale
+            interaction.locale,
           );
           extract =
             extract.substring(0, MAX_EXTRACT_LENGTH - truncatedText.length - 2) +
···
 
         const readMore = await client.getLocaleText(
           'commands.wiki.readmoreonwiki',
-          interaction.locale
+          interaction.locale,
         );
         const title = await client.getLocaleText('commands.wiki.pedia', interaction.locale, {
           article: article.title,
···
         const embed = new EmbedBuilder()
           .setTitle(title)
           .setURL(
-            `https://${wikiLang}.wikipedia.org/wiki/${encodeURIComponent(article.title.replace(/ /g, '_'))}`
+            `https://${wikiLang}.wikipedia.org/wiki/${encodeURIComponent(article.title.replace(/ /g, '_'))}`,
           )
           .setDescription(extract)
           .setColor(0x4285f4)

src/events/interactionCreate.ts

···
                 content: `You have been banned from using Aethel commands for 7 days due to repeated use of unallowed language. Ban expires: <t:${Math.floor(new Date(banned_until).getTime() / 1000)}:F>.`,
                 flags: MessageFlags.Ephemeral,
               });
-            } else {
-              return i.reply({
-                content: `Your request was flagged by Aethel for ${category}. You have ${strike_count}/5 strikes. For more information, visit https://aethel.xyz/legal/terms`,
-                flags: MessageFlags.Ephemeral,
-              });
             }
+            return i.reply({
+              content: `Your request was flagged by Aethel for ${category}. You have ${strike_count}/5 strikes. For more information, visit https://aethel.xyz/legal/terms`,
+              flags: MessageFlags.Ephemeral,
+            });
           }
         }
       }
···
                       ? await this.client.getLocaleText('reddit.from', i.locale, {
                           subreddit: data.subreddit,
                         })
-                      : ''
-                  )
+                      : '',
+                  ),
                 )
                 .addMediaGalleryComponents(
-                  new MediaGalleryBuilder().addItems(new MediaGalleryItemBuilder().setURL(data.url))
+                  new MediaGalleryBuilder().addItems(
+                    new MediaGalleryItemBuilder().setURL(data.url),
+                  ),
                 )
                 .addActionRowComponents(
                   new ActionRowBuilder<ButtonBuilder>().addComponents(
···
                       .setStyle(ButtonStyle.Danger)
                       .setLabel(refreshLabel)
                       .setEmoji({ name: '🐱' })
-                      .setCustomId('refresh_cat')
-                  )
+                      .setCustomId('refresh_cat'),
+                  ),
                 );
 
               await i.update({
···
             } else {
               const container = new ContainerBuilder().addTextDisplayComponents(
                 new TextDisplayBuilder().setContent(
-                  await this.client.getLocaleText('commands.cat.error', i.locale)
-                )
+                  await this.client.getLocaleText('commands.cat.error', i.locale),
+                ),
               );
 
               await i.update({
···
             logger.error('Error refreshing cat image:', error);
             const container = new ContainerBuilder().addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                await this.client.getLocaleText('commands.cat.error', i.locale)
-              )
+                await this.client.getLocaleText('commands.cat.error', i.locale),
+              ),
             );
 
             await i.update({
···
 
           for (const cmd of this.client.commands.values()) {
             const ClientApplicationCommandCache = this.client.application?.commands.cache.find(
-              (command) => command.name == cmd.data.name
+              (command) => command.name === cmd.data.name,
             );
             const category = cmd.category || 'Uncategorized';
             if (!commandCategories.has(category)) {
···
 
             const localizedDescription = await this.client.getLocaleText(
               `commands.${cmd.data.name}.description`,
-              i.locale
+              i.locale,
             );
             commandCategories
               .get(category)!
               .push(
-                `</${ClientApplicationCommandCache?.name}:${ClientApplicationCommandCache?.id}> - ${localizedDescription}`
+                `</${ClientApplicationCommandCache?.name}:${ClientApplicationCommandCache?.id}> - ${localizedDescription}`,
               );
           }
 
           const container = new ContainerBuilder()
             .setAccentColor(0x5865f2)
             .addTextDisplayComponents(
-              new TextDisplayBuilder().setContent('# 📋 **Available Commands**')
+              new TextDisplayBuilder().setContent('# 📋 **Available Commands**'),
             );
 
           for (const [category, cmds] of commandCategories.entries()) {
             const localizedCategory = await this.client.getLocaleText(
               `categories.${category}`,
-              i.locale
+              i.locale,
             );
 
             container.addTextDisplayComponents(
-              new TextDisplayBuilder().setContent(`\n## 📂 ${localizedCategory}`)
+              new TextDisplayBuilder().setContent(`\n## 📂 ${localizedCategory}`),
             );
 
             container.addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                cmds.map((line) => line.replace(/\u007F/g, '')).join('\n')
-              )
+                cmds.map((line) => line.replace(/\u007F/g, '')).join('\n'),
+              ),
             );
           }
 
···
                 .setStyle(ButtonStyle.Secondary)
                 .setLabel(backLabel)
                 .setEmoji({ name: '⬅️' })
-                .setCustomId(`help_back_${i.user.id}`)
-            )
+                .setCustomId(`help_back_${i.user.id}`),
+            ),
           );
 
           await i.update({
···
 
             .addMediaGalleryComponents(
               new MediaGalleryBuilder().addItems(
-                new MediaGalleryItemBuilder().setURL('https://aethel.xyz/aethel_banner_white.png')
-              )
+                new MediaGalleryItemBuilder().setURL('https://aethel.xyz/aethel_banner_white.png'),
+              ),
             )
             .addTextDisplayComponents(
-              new TextDisplayBuilder().setContent(`# ${title || 'Aethel Bot'}`)
+              new TextDisplayBuilder().setContent(`# ${title || 'Aethel Bot'}`),
             )
             .addTextDisplayComponents(
-              new TextDisplayBuilder().setContent(description || 'Get information about Aethel')
+              new TextDisplayBuilder().setContent(description || 'Get information about Aethel'),
             )
             .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
             .addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                `\n## **${linksSocialText || 'Links & Social Media'}**`
-              )
+                `\n## **${linksSocialText || 'Links & Social Media'}**`,
+              ),
             )
             .addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                '[Website](https://aethel.xyz) • [GitHub](https://github.com/aethel-labs/aethel) • [Bluesky](https://bsky.app/profile/aethel.xyz)'
-              )
+                '[Website](https://aethel.xyz) • [GitHub](https://github.com/aethel-labs/aethel) • [Bluesky](https://bsky.app/profile/aethel.xyz)',
+              ),
             )
             .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
             .addTextDisplayComponents(
-              new TextDisplayBuilder().setContent(`\n## **${featuresText || 'Features'}**`)
+              new TextDisplayBuilder().setContent(`\n## **${featuresText || 'Features'}**`),
             )
             .addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
···
                     '**AI Integration** - Powered by OpenAI and other providers\n' +
                     '**Reminders** - Never forget important tasks\n' +
                     '**Utilities** - Weather, help, and productivity tools\n' +
-                    '**Multi-language** - Supports multiple languages'
-              )
+                    '**Multi-language** - Supports multiple languages',
+              ),
             )
 
             .addSeparatorComponents(
-              new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large).setDivider(true)
+              new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large).setDivider(true),
             )
             .addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                `-# ${dashboardText || 'Dashboard available at https://aethel.xyz/login for To-Dos, Reminders and custom AI API key management'}`
-              )
+                `-# ${dashboardText || 'Dashboard available at https://aethel.xyz/login for To-Dos, Reminders and custom AI API key management'}`,
+              ),
             )
             .addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Large))
             .addActionRowComponents(
···
                 new ButtonBuilder()
                   .setStyle(ButtonStyle.Link)
                   .setLabel(supportServerText || 'Support')
-                  .setURL('https://discord.gg/63stE8pEaK')
-              )
+                  .setURL('https://discord.gg/63stE8pEaK'),
+              ),
             );
 
           await i.update({
···
             if (!response.ok) {
               const container = new ContainerBuilder().addTextDisplayComponents(
                 new TextDisplayBuilder().setContent(
-                  await this.client.getLocaleText('commands.dog.error', i.locale)
-                )
+                  await this.client.getLocaleText('commands.dog.error', i.locale),
+                ),
               );
 
               return await i.update({
···
                       ? await this.client.getLocaleText('reddit.from', i.locale, {
                           subreddit: data!.subreddit,
                         })
-                      : ''
-                  )
+                      : '',
+                  ),
                 )
                 .addMediaGalleryComponents(
                   new MediaGalleryBuilder().addItems(
-                    new MediaGalleryItemBuilder().setURL(data!.url)
-                  )
+                    new MediaGalleryItemBuilder().setURL(data!.url),
+                  ),
                 )
                 .addActionRowComponents(
                   new ActionRowBuilder<ButtonBuilder>().addComponents(
···
                       .setStyle(ButtonStyle.Secondary)
                       .setLabel(refreshLabel)
                       .setEmoji({ name: '🐶' })
-                      .setCustomId('refresh_dog')
-                  )
+                      .setCustomId('refresh_dog'),
+                  ),
                 );
 
               await i.update({
···
             } else {
               const container = new ContainerBuilder().addTextDisplayComponents(
                 new TextDisplayBuilder().setContent(
-                  await this.client.getLocaleText('commands.dog.error', i.locale)
-                )
+                  await this.client.getLocaleText('commands.dog.error', i.locale),
+                ),
               );
 
               await i.update({
···
             logger.error('Error refreshing dog image:', error);
             const container = new ContainerBuilder().addTextDisplayComponents(
               new TextDisplayBuilder().setContent(
-                await this.client.getLocaleText('commands.dog.error', i.locale)
-              )
+                await this.client.getLocaleText('commands.dog.error', i.locale),
+              ),
             );
 
             await i.update({
···
           components: [],
         });
       }
-      return;
     }
   };
 }

src/events/messageCreate.ts

···
 
     if (!isDM && !isMentioned) {
       logger.debug(
-        `Ignoring message - not a DM and bot not mentioned (channel type: ${message.channel.type})`
+        `Ignoring message - not a DM and bot not mentioned (channel type: ${message.channel.type})`,
       );
       return;
     }
···
       const hasImageAttachments = message.attachments.some(
         (att) =>
           att.contentType?.startsWith('image/') ||
-          att.name?.match(/\.(jpg|jpeg|png|gif|webp|bmp|svg)$/i)
+          att.name?.match(/\.(jpg|jpeg|png|gif|webp|bmp|svg)$/i),
       );
 
       const hasImageUrls = false;
···
         : userCustomModel || 'moonshotai/kimi-k2';
 
       logger.info(
-        `Using model: ${selectedModel} for message with images: ${hasImages}${userCustomModel ? ' (user custom model)' : ' (default model)'}`
+        `Using model: ${selectedModel} for message with images: ${hasImages}${userCustomModel ? ' (user custom model)' : ' (default model)'}`,
       );
 
       const systemPrompt = buildSystemPrompt(
         isDM,
         this.client,
         selectedModel,
-        message.author.username
+        message.author.username,
       );
 
       let messageContent:
···
         const imageAttachments = message.attachments.filter(
           (att) =>
             att.contentType?.startsWith('image/') ||
-            att.name?.match(/\.(jpg|jpeg|png|gif|webp|bmp|svg)$/i)
+            att.name?.match(/\.(jpg|jpeg|png|gif|webp|bmp|svg)$/i),
         );
 
         const contentArray: Array<{
···
       const updatedConversation = buildConversation(
         filteredConversation,
         messageContent,
-        systemPrompt
+        systemPrompt,
       );
 
       const { apiKey: userApiKey, apiUrl: userApiUrl } = await getUserCredentials(
-        message.author.id
+        message.author.id,
       );
       const config = getApiConfiguration(userApiKey ?? null, selectedModel, userApiUrl ?? null);
 
···
           const allowed = await incrementAndCheckDailyLimit(message.author.id, 10);
           if (!allowed) {
             await message.reply(
-              "❌ You've reached your daily limit of AI requests. Please try again tomorrow or set up your own API key using the `/ai` command."
+              "❌ You've reached your daily limit of AI requests. Please try again tomorrow or set up your own API key using the `/ai` command.",
             );
             return;
           }
···
         const fallbackConversation = buildConversation(
           cleanedConversation,
           fallbackContent,
-          buildSystemPrompt(isDM, this.client, fallbackModel, message.author.username)
+          buildSystemPrompt(isDM, this.client, fallbackModel, message.author.username),
         );
 
         const fallbackConfig = getApiConfiguration(
           userApiKey ?? null,
           fallbackModel,
-          userApiUrl ?? null
+          userApiUrl ?? null,
         );
         aiResponse = await makeAIRequest(fallbackConfig, fallbackConversation);
 
···
 
       if (!aiResponse) {
         await message.reply(
-          'Sorry, I encountered an error processing your message. Please try again later.'
+          'Sorry, I encountered an error processing your message. Please try again later.',
         );
         return;
       }
···
     } catch (error) {
       logger.error(
         `Error processing ${isDM ? 'DM' : 'server message'}:`,
-        error instanceof Error ? error.message : String(error)
+        error instanceof Error ? error.message : String(error),
       );
       try {
         await message.reply(
-          'Sorry, I encountered an error processing your message. Please try again later.'
+          'Sorry, I encountered an error processing your message. Please try again later.',
         );
       } catch (replyError) {
         logger.error('Failed to send error message:', replyError);

src/handlers/initialzeCommands.ts

···
   const commands: (SlashCommandBuilder | ContextMenuCommandBuilder)[] = [];
   for (const cat of cmdCat) {
     const commandFiles = readdirSync(path.join(cmdDir, cat)).filter(
-      (f) => f.endsWith('.js') || f.endsWith('.ts')
+      (f) => f.endsWith('.js') || f.endsWith('.ts'),
     );
     for (const file of commandFiles) {
       const commandPath = path.join(cmdDir, cat, file);

src/index.ts

···
     allowedHeaders: ['Content-Type', 'X-API-Key', 'Authorization', 'Cache-Control', 'Pragma'],
     credentials: true,
     maxAge: 86400,
-  })
+  }),
 );
 app.set('trust proxy', 1);
 app.use(
···
     message: { error: 'Too many requests, please try again later.' },
     standardHeaders: true,
     legacyHeaders: false,
-  })
+  }),
 );
 
 app.use(e.json({ limit: '10mb' }));
···
   } else {
     res.setHeader(
       'Content-Security-Policy',
-      "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: https:; font-src 'self' data: https://fonts.gstatic.com; connect-src 'self' https:"
+      "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: https:; font-src 'self' data: https://fonts.gstatic.com; connect-src 'self' https:",
     );
   }
   next();
···
   () => {
     resetOldStrikes().catch(console.error);
   },
-  60 * 60 * 1000
+  60 * 60 * 1000,
 );
 
 app.listen(PORT, () => {

src/middlewares/auth.ts

···
     } else if (error instanceof jwt.JsonWebTokenError) {
       logger.debug('Invalid JWT token used');
       return res.status(401).json({ error: 'Invalid token' });
-    } else {
-      logger.error('JWT verification error:', error);
-      return res.status(500).json({ error: 'Token verification failed' });
     }
+    logger.error('JWT verification error:', error);
+    return res.status(500).json({ error: 'Token verification failed' });
   }
 };
 

src/middlewares/verifyApiKey.ts

···
 
 const authenticateApiKey: RequestHandler = (req, res, next) => {
   const apiKey = req.headers['x-api-key'];
-  if (!apiKey || typeof apiKey != 'string') {
+  if (!apiKey || typeof apiKey !== 'string') {
     res.status(401).json({ error: 'Unauthorized: Missing API key' });
     return;
   }

src/routes/apiKeys.ts

···
       logger.error('Error updating API key:', error);
       res.status(500).json({ error: 'Internal server error' });
     }
-  }
+  },
 );
 
 router.put(
···
       logger.error('Error updating API key:', error);
       res.status(500).json({ error: 'Internal server error' });
     }
-  }
+  },
 );
 
 router.delete('/', async (req, res) => {
···
 
       res.status(500).json({ error: 'API key test failed due to server error' });
     }
-  }
+  },
 );
 
 export default router;

src/routes/auth.ts

···
         'INSERT INTO users (user_id, language, created_at) VALUES ($1, $2, NOW())';
       await pool.query(insertQuery, [discordUser.id, 'en']);
       logger.info(
-        `New user created: ${discordUser.username}#${discordUser.discriminator} (${discordUser.id})`
+        `New user created: ${discordUser.username}#${discordUser.discriminator} (${discordUser.id})`,
       );
     }
 
···
         avatar: discordUser.avatar,
       },
       JWT_SECRET,
-      { expiresIn: '7d' }
+      { expiresIn: '7d' },
     );
 
     const redirectUrl = new URL(`${FRONTEND_URL}/login`);

src/routes/reminders.ts

···
 
         if (scheduled) {
           logger.info(
-            `Successfully scheduled reminder ${savedReminder.reminder_id} from dashboard`
+            `Successfully scheduled reminder ${savedReminder.reminder_id} from dashboard`,
           );
         } else {
           logger.warn(`Failed to schedule reminder ${savedReminder.reminder_id} from dashboard`);
···
         if (user) {
           const minutes = Math.floor(
             (new Date(reminder.expires_at).getTime() - new Date(reminder.created_at!).getTime()) /
-              (60 * 1000)
+              (60 * 1000),
           );
 
           const reminderTitle =
···
           const reminderDesc = await client.getLocaleText(
             'commands.remind.remindyou',
             reminder.locale,
-            { message: reminder.message }
+            { message: reminder.message },
           );
 
           const timeElapsedText =
···
                 name: originalTimeText,
                 value: `<t:${Math.floor(new Date(reminder.created_at!).getTime() / 1000)}:f>`,
                 inline: true,
-              }
+              },
             )
             .setFooter({ text: `ID: ${reminder.reminder_id.slice(-6)}` })
             .setTimestamp();
···
           if (reminder.metadata?.message_url) {
             const originalMessageText = await client.getLocaleText(
               'common.ogmessage',
-              reminder.locale
+              reminder.locale,
             );
             const jumpToMessageText = await client.getLocaleText(
               'common.jumptomessage',
-              reminder.locale
+              reminder.locale,
             );
 
             reminderEmbed.addFields({
···
           if (reminder.message.includes('http') && !reminder.metadata?.message_url) {
             const messageLinkText = await client.getLocaleText(
               'common.messagelink',
-              reminder.locale
+              reminder.locale,
             );
             reminderEmbed.addFields({
               name: messageLinkText,
···
         {
           error: notificationError,
           reminderId: reminder.reminder_id,
-        }
+        },
       );
     }
 

src/routes/todos.ts

···
       logger.error('Error creating todo:', error);
       res.status(500).json({ error: 'Internal server error' });
     }
-  }
+  },
 );
 
 router.put(
···
       logger.error('Error updating todo:', error);
       res.status(500).json({ error: 'Internal server error' });
     }
-  }
+  },
 );
 
 router.delete('/:id', async (req, res) => {

src/utils/commandLogger.ts

···
 
 export interface CommandLogOptions {
   commandName: string;
-  userId: string;
-  username: string;
   additionalInfo?: string;
-  guildId?: string;
-  channelId?: string;
+  isGuild?: boolean;
+  isDM?: boolean;
 }
 
 export function logUserAction(options: CommandLogOptions): void {
-  const { commandName, userId, username, guildId, channelId, additionalInfo } = options;
-
-  let logMessage = `User ${username} (${userId}) used ${commandName} command`;
+  const { commandName, isGuild, isDM, additionalInfo } = options;
 
-  if (guildId) {
-    logMessage += ` in guild ${guildId}`;
-  }
+  let logMessage = `User executed ${commandName} command`;
 
-  if (channelId) {
-    logMessage += ` in channel ${channelId}`;
+  if (isGuild) {
+    logMessage += ` in guild`;
+  } else if (isDM) {
+    logMessage += ` in DM`;
   }
 
   if (additionalInfo) {
···
 export function logUserActionFromInteraction(
   interaction: CommandInteraction,
   commandName: string,
-  additionalInfo?: string
+  additionalInfo?: string,
 ): void {
   logUserAction({
     commandName,
-    userId: interaction.user.id,
-    username: interaction.user.tag,
-    guildId: interaction.guildId || undefined,
-    channelId: interaction.channelId,
+    isGuild: !!interaction.guildId,
+    isDM: !interaction.guildId,
     additionalInfo,
   });
 }

src/utils/cooldown.ts

···
       }
     }
   },
-  5 * 60 * 1000
+  5 * 60 * 1000,
 );
 
 export function createCooldownManager(commandName: string, cooldownTime: number): CooldownManager {
···
   manager: CooldownManager,
   userId: string,
   client: BotClient,
-  locale: string
+  locale: string,
 ): Promise<{ onCooldown: boolean; timeLeft?: number; message?: string }> {
   const now = Date.now();
   const cooldownEnd = manager.cooldowns.get(userId) || 0;

src/utils/dynamicFetch.ts

···
     message: string,
     public readonly status?: number,
     public readonly statusText?: string,
-    public readonly url?: string
+    public readonly url?: string,
   ) {
     super(message);
     this.name = 'FetchError';
···
             `Request timeout after ${timeout}ms`,
             undefined,
             undefined,
-            url.toString()
+            url.toString(),
           );
         }
 
···
             `Client error: ${error.message}`,
             error.status,
             'statusText' in error ? (error.statusText as string) : undefined,
-            url.toString()
+            url.toString(),
           );
         }
       }
···
     `Request failed after ${retries + 1} attempts: ${lastError?.message || 'Unknown error'}`,
     undefined,
     undefined,
-    url.toString()
+    url.toString(),
   );
 };
 

src/utils/encrypt.ts

···
 class EncryptionError extends Error {
   constructor(
     message: string,
-    public readonly operation: 'encrypt' | 'decrypt'
+    public readonly operation: 'encrypt' | 'decrypt',
   ) {
     super(message);
     this.name = 'EncryptionError';
···
   if (!encrypted || typeof encrypted !== 'string') {
     throw new EncryptionError(
       'Invalid input: encrypted data must be a non-empty string',
-      'decrypt'
+      'decrypt',
     );
   }
 
···
     if (iv.length !== IV_LENGTH) {
       throw new EncryptionError(
         `Invalid IV length: expected ${IV_LENGTH}, got ${iv.length}`,
-        'decrypt'
+        'decrypt',
       );
     }
 
     if (tag.length !== 16) {
       throw new EncryptionError(
         `Invalid auth tag length: expected 16, got ${tag.length}`,
-        'decrypt'
+        'decrypt',
       );
     }
 
···
     if (error instanceof Error) {
       if (error.message.includes('Unsupported state or unable to authenticate data')) {
         logger.warn(
-          'Authentication failed during decryption - data may be corrupted or key changed'
+          'Authentication failed during decryption - data may be corrupted or key changed',
         );
         throw new EncryptionError(
           'Authentication failed - data may be corrupted or encryption key changed',
-          'decrypt'
+          'decrypt',
         );
       }
       if (error.message.includes('Invalid key length')) {

src/utils/getGitCommitHash.ts

···
   return cachedCommitHash || getGitCommitHashSync();
 }
 
-initializeGitCommitHash().catch(() => {});
+initializeGitCommitHash().catch((error) => {
+  console.warn('Failed to initialize git commit hash:', error.message);
+});
 
 export default getGitCommitHash;

src/utils/logger.ts

···
 import path from 'path';
 
 const sanitizeFormat = winston.format((info) => {
-  const sensitiveKeys = ['password', 'token', 'api_key', 'secret', 'authorization'];
+  const sensitiveKeys = [
+    'password',
+    'token',
+    'api_key',
+    'secret',
+    'authorization',
+    'userid',
+    'user_id',
+    'username',
+    'user_tag',
+    'guildid',
+    'guild_id',
+    'channelid',
+    'channel_id',
+  ];
 
   const sanitize = (obj: unknown): unknown => {
     if (typeof obj !== 'object' || obj === null) return obj;
···
     for (const key in sanitized) {
       if (sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive))) {
         sanitized[key] = '[REDACTED]';
+      } else if (typeof sanitized[key] === 'string') {
+        sanitized[key] = (sanitized[key] as string).replace(/\b\d{17,19}\b/g, '[ID_REDACTED]');
       } else if (typeof sanitized[key] === 'object') {
         sanitized[key] = sanitize(sanitized[key]);
       }
···
     winston.format.errors({ stack: true }),
     sanitizeFormat(),
     winston.format.splat(),
-    winston.format.json()
+    winston.format.json(),
   ),
   defaultMeta: {
     service: 'Aethel',
···
         winston.format.printf(({ timestamp, level, message, service, ...meta }) => {
           const metaStr = Object.keys(meta).length ? JSON.stringify(meta, null, 2) : '';
           return `${timestamp} [${service}] ${level}: ${message} ${metaStr}`;
-        })
+        }),
       ),
     }),
   ],
···
       maxsize: 5242880,
       maxFiles: 5,
       format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
-    })
+    }),
   );
 
   logger.add(
···
       maxsize: 5242880,
       maxFiles: 5,
       format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
-    })
+    }),
   );
 }
 
 logger.exceptions.handle(
   new winston.transports.Console({
     format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-  })
+  }),
 );
 
 logger.rejections.handle(
   new winston.transports.Console({
     format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-  })
+  }),
 );
 
 export default logger;

src/utils/memoryManager.ts

···
       const result = [...entry];
       delete (result as unknown as Record<string, unknown>).timestamp;
       return result as V;
-    } else {
-      const { timestamp: _timestamp, ...valueWithoutTimestamp } = entry;
-      return valueWithoutTimestamp as V;
     }
+    const { timestamp: _timestamp, ...valueWithoutTimestamp } = entry;
+    return valueWithoutTimestamp as V;
   }
 
   delete(key: K): boolean {

src/utils/reminderDb.ts

···
       return new DatabaseError(
         errorMessage,
         'Unable to connect to the database. Please try again later.',
-        true
+        true,
       );
     case '42703':
       return new DatabaseError(
         errorMessage,
         'Database schema error. Please contact support.',
-        true
+        true,
       );
     case '23505':
       return new DatabaseError(errorMessage, 'This reminder already exists.', true);
···
       return new DatabaseError(
         errorMessage,
         'Missing required information. Please try again.',
-        true
+        true,
       );
     case '23503':
       return new DatabaseError(errorMessage, 'Invalid reference. Please try again.', true);
···
       return new DatabaseError(
         errorMessage,
         'A database error occurred. Please try again later.',
-        false
+        false,
       );
   }
 }
···
 async function ensureUserRegistered(
   userId: string,
   userTag: string,
-  language: string = 'en'
+  language = 'en',
 ): Promise<void> {
   const query = `
     SELECT ensure_user_registered($1, $2, $3)
···
   await ensureUserRegistered(
     reminderData.user_id,
     reminderData.user_tag,
-    reminderData.locale || 'en'
+    reminderData.locale || 'en',
   );
 
   const query = `

src/utils/userStrikes.ts

···
 export class StrikeError extends Error {
   constructor(
     message: string,
-    public readonly userId?: string
+    public readonly userId?: string,
   ) {
     super(message);
     this.name = 'StrikeError';
···
   try {
     const res = await pgClient.query(
       'SELECT strike_count, banned_until FROM user_strikes WHERE user_id = $1',
-      [userId]
+      [userId],
     );
 
     if (res.rows.length === 0) {
···
         last_strike_at = NOW()
       RETURNING strike_count, banned_until;
     `,
-      [userId]
+      [userId],
     );
 
     if (res.rows.length === 0) {
···
       `UPDATE user_strikes
        SET strike_count = 0, banned_until = NULL
        WHERE last_strike_at < NOW() - INTERVAL '3 days'
-       RETURNING user_id`
+       RETURNING user_id`,
     );
 
     const resetCount = res.rows.length;
···
   try {
     const res = await pgClient.query(
       'UPDATE user_strikes SET strike_count = 0, banned_until = NULL WHERE user_id = $1',
-      [userId]
+      [userId],
     );
 
     logger.info('Cleared user strikes', { userId });

src/utils/validation.ts

···
 
 function validateCommandOptions(
   interaction: ChatInputCommandInteraction,
-  requiredOptions: string[] = []
+  requiredOptions: string[] = [],
 ): ValidationResult {
   for (const option of requiredOptions) {
     const value = interaction.options.getString(option);

web/src/App.tsx

···
   return (
     <Routes>
       {/* Public routes */}
-      <Route path="/" element={<LandingPage />} />
+      <Route
+        path="/"
+        element={<LandingPage />}
+      />
       <Route
         path="/login"
-        element={isAuthenticated ? <Navigate to="/dashboard" replace /> : <LoginPage />}
+        element={
+          isAuthenticated ? (
+            <Navigate
+              to="/dashboard"
+              replace
+            />
+          ) : (
+            <LoginPage />
+          )
+        }
       />
-      <Route path="/status" element={<StatusPage />} />
-      <Route path="/legal/privacy" element={<PrivacyPage />} />
-      <Route path="/legal/terms" element={<TermsPage />} />
+      <Route
+        path="/status"
+        element={<StatusPage />}
+      />
+      <Route
+        path="/legal/privacy"
+        element={<PrivacyPage />}
+      />
+      <Route
+        path="/legal/terms"
+        element={<TermsPage />}
+      />
 
       {/* Protected routes */}
       {isAuthenticated ? (
···
           element={
             <Layout>
               <Routes>
-                <Route path="/dashboard" element={<DashboardPage />} />
-                <Route path="/todos" element={<TodosPage />} />
-                <Route path="/reminders" element={<RemindersPage />} />
-                <Route path="/api-keys" element={<ApiKeysPage />} />
-                <Route path="*" element={<Navigate to="/dashboard" replace />} />
+                <Route
+                  path="/dashboard"
+                  element={<DashboardPage />}
+                />
+                <Route
+                  path="/todos"
+                  element={<TodosPage />}
+                />
+                <Route
+                  path="/reminders"
+                  element={<RemindersPage />}
+                />
+                <Route
+                  path="/api-keys"
+                  element={<ApiKeysPage />}
+                />
+                <Route
+                  path="*"
+                  element={
+                    <Navigate
+                      to="/dashboard"
+                      replace
+                    />
+                  }
+                />
               </Routes>
             </Layout>
           }
         />
       ) : (
-        <Route path="*" element={<Navigate to="/" replace />} />
+        <Route
+          path="*"
+          element={
+            <Navigate
+              to="/"
+              replace
+            />
+          }
+        />
       )}
     </Routes>
   );

web/src/components/Layout.tsx

···
           mobileMenuOpen ? 'opacity-100' : 'opacity-0 pointer-events-none'
         }`}
       >
-        <div className="fixed inset-0 bg-black/70" onClick={() => setMobileMenuOpen(false)} />
+        <div
+          className="fixed inset-0 bg-black/70"
+          onClick={() => setMobileMenuOpen(false)}
+        />
         <div
           className={`fixed inset-y-0 left-0 flex w-72 flex-col bg-white/90 dark:bg-gray-800/90 backdrop-blur-md shadow-xl transform transition-transform duration-200 ease-out ${
             mobileMenuOpen ? 'translate-x-0' : '-translate-x-full'

web/src/components/LegalLayout.tsx

···
             to="/"
             className="inline-flex items-center px-6 py-3 bg-white/90 hover:bg-white dark:bg-gray-800/90 dark:hover:bg-gray-800 text-gray-800 dark:text-gray-100 font-medium rounded-full shadow-md hover:shadow-lg transition-all mb-8"
           >
-            <svg className="w-4 h-4 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <svg
+              className="w-4 h-4 mr-2"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+            >
               <path
                 strokeLinecap="round"
                 strokeLinejoin="round"

web/src/lib/api.ts

···
   },
   (error) => {
     return Promise.reject(error);
-  }
+  },
 );
 
 api.interceptors.response.use(
···
       toast.error('An unexpected error occurred.');
     }
     return Promise.reject(error);
-  }
+  },
 );
 
 export default api;

web/src/main.tsx

···
         <Toaster position="top-right" />
       </BrowserRouter>
     </QueryClientProvider>
-  </React.StrictMode>
+  </React.StrictMode>,
 );

web/src/pages/ApiKeysPage.tsx

···
             {apiKeyInfo?.hasApiKey ? 'Update' : 'Configure'} API Key
           </h2>
 
-          <form onSubmit={handleSubmit} className="space-y-4">
+          <form
+            onSubmit={handleSubmit}
+            className="space-y-4"
+          >
             <div>
               <p className="text-sm text-gray-600 dark:text-gray-300 mb-4">
                 <span className="text-red-600 dark:text-red-400">*</span> You must test the API key

web/src/pages/DashboardPage.tsx

···
   const recentTodos = activeTodosForDisplay.slice(0, 5);
   const activeRemindersForDisplay =
     reminders?.filter(
-      (reminder: Reminder) => !reminder.completed && new Date(reminder.expires_at) >= new Date()
+      (reminder: Reminder) => !reminder.completed && new Date(reminder.expires_at) >= new Date(),
     ) || [];
   const recentReminders = activeRemindersForDisplay.slice(0, 5);
 
···
             {recentTodos.length > 0 ? (
               <div className="space-y-3">
                 {recentTodos.slice(0, 5).map((todo: Todo) => (
-                  <div key={todo.id} className="stats-card">
+                  <div
+                    key={todo.id}
+                    className="stats-card"
+                  >
                     <div className="flex items-center justify-between">
                       <div className="flex items-center space-x-3 flex-1">
                         <div
···
                   const daysOverdue = isOverdue
                     ? Math.ceil(
                         (Date.now() - new Date(reminder.expires_at).getTime()) /
-                          (1000 * 60 * 60 * 24)
+                          (1000 * 60 * 60 * 24),
                       )
                     : 0;
 
                   return (
-                    <div key={reminder.reminder_id} className="stats-card">
+                    <div
+                      key={reminder.reminder_id}
+                      className="stats-card"
+                    >
                       <div className="flex items-center justify-between">
                         <div className="flex items-center space-x-3 flex-1">
                           <div

web/src/pages/LandingPage.tsx

···
           className="p-3 bg-white dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700 text-black dark:text-white rounded-full transition-all transform hover:scale-110 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-gray-300 dark:focus:ring-gray-600 shadow-lg hover:shadow-xl"
           aria-label="View on GitHub"
         >
-          <svg className="w-6 h-6" fill="currentColor" viewBox="0 0 24 24" aria-hidden="true">
+          <svg
+            className="w-6 h-6"
+            fill="currentColor"
+            viewBox="0 0 24 24"
+            aria-hidden="true"
+          >
             <path
               fillRule="evenodd"
               d="M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z"
···
 
       <footer className="mt-16 text-center text-gray-500 dark:text-gray-400 pb-8">
         <div className="flex flex-wrap justify-center gap-6 mb-6">
-          <Link to="/legal/privacy" className="hover:text-pink-500 transition-colors text-sm">
+          <Link
+            to="/legal/privacy"
+            className="hover:text-pink-500 transition-colors text-sm"
+          >
             Privacy Policy
           </Link>
-          <Link to="/legal/terms" className="hover:text-pink-500 transition-colors text-sm">
+          <Link
+            to="/legal/terms"
+            className="hover:text-pink-500 transition-colors text-sm"
+          >
             Terms of Service
           </Link>
         </div>
···
             rel="noopener noreferrer"
             className="inline-block hover:opacity-80 transition-opacity"
           >
-            <img src="/royale_logo.svg" alt="Royale Hosting" className="h-6 mx-auto dark:hidden" />
+            <img
+              src="/royale_logo.svg"
+              alt="Royale Hosting"
+              className="h-6 mx-auto dark:hidden"
+            />
             <img
               src="/royale_logo_dark.svg"
               alt="Royale Hosting"

web/src/pages/LoginPage.tsx

···
               onClick={handleDiscordLogin}
               className="w-full flex items-center justify-center px-8 py-3 border border-transparent rounded-full shadow-sm text-white bg-[#5865F2] hover:bg-[#4752c4] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-[#5865F2] transition-all transform hover:scale-105 font-bold shadow-lg hover:shadow-xl"
             >
-              <svg className="w-5 h-5 mr-3" viewBox="0 0 24 24" fill="currentColor">
+              <svg
+                className="w-5 h-5 mr-3"
+                viewBox="0 0 24 24"
+                fill="currentColor"
+              >
                 <path d="M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515a.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0a12.64 12.64 0 0 0-.617-1.25a.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057a19.9 19.9 0 0 0 5.993 3.03a.078.078 0 0 0 .084-.028a14.09 14.09 0 0 0 1.226-1.994a.076.076 0 0 0-.041-.106a13.107 13.107 0 0 1-1.872-.892a.077.077 0 0 1-.008-.128a10.2 10.2 0 0 0 .372-.292a.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127a12.299 12.299 0 0 1-1.873.892a.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028a19.839 19.839 0 0 0 6.002-3.03a.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.956-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.955-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.946 2.418-2.157 2.418z" />
               </svg>
               Continue with Discord

web/src/pages/PrivacyPage.tsx

···
 
 export default function PrivacyPolicy() {
   return (
-    <LegalLayout title="Privacy Policy" lastUpdated="July 26, 2025">
+    <LegalLayout
+      title="Privacy Policy"
+      lastUpdated="July 26, 2025"
+    >
       <div className="space-y-8">
         <section>
           <h2 className="text-2xl font-semibold text-gray-800 dark:text-gray-200 mb-4">

web/src/pages/RemindersPage.tsx

···
           <h2 className="text-lg sm:text-xl font-semibold mb-4 sm:mb-6 text-gray-900 dark:text-gray-100">
             Create New Reminder
           </h2>
-          <form onSubmit={handleCreateReminder} className="space-y-4 sm:space-y-6">
+          <form
+            onSubmit={handleCreateReminder}
+            className="space-y-4 sm:space-y-6"
+          >
             <div>
               <label
                 htmlFor="message"

web/src/pages/StatusPage.tsx

···
         headers: {
           'X-API-Key': import.meta.env.VITE_STATUS_API_KEY || '',
         },
-      }
+      },
     );
 
     if (!response.ok) {
···
               to="/"
               className="inline-flex items-center px-6 py-3 bg-white/90 hover:bg-white dark:bg-gray-800/90 dark:hover:bg-gray-800 text-gray-800 dark:text-gray-100 font-medium rounded-full shadow-md hover:shadow-lg transition-all"
             >
-              <svg className="w-4 h-4 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <svg
+                className="w-4 h-4 mr-2"
+                fill="none"
+                stroke="currentColor"
+                viewBox="0 0 24 24"
+              >
                 <path
                   strokeLinecap="round"
                   strokeLinejoin="round"

web/src/pages/TermsPage.tsx

···
 
 export default function TermsOfService() {
   return (
-    <LegalLayout title="Terms of Service" lastUpdated="June 16, 2025">
+    <LegalLayout
+      title="Terms of Service"
+      lastUpdated="June 16, 2025"
+    >
       <div className="space-y-8">
         <section>
           <h2 className="text-2xl font-semibold text-gray-800 dark:text-gray-200 mb-4">

web/src/pages/TodosPage.tsx

···
       </div>
 
       <div className="card p-6">
-        <form onSubmit={handleAddTodo} className="flex gap-3">
+        <form
+          onSubmit={handleAddTodo}
+          className="flex gap-3"
+        >
           <input
             type="text"
             value={newTodo}

web/src/stores/authStore.ts

···
         user: state.user,
         isAuthenticated: state.isAuthenticated,
       }),
-    }
-  )
+    },
+  ),
 );

web/src/stores/themeStore.ts

···
           updateBodyClass(state.isDarkMode);
         }
       },
-    }
-  )
+    },
+  ),
 );
 
 function updateBodyClass(isDark: boolean) {