iobroker.poolcontrol 1.2.0 → 1.2.1

package/lib/helpers/aiChemistryHelpHelper.js

@@ -38,7 +38,7 @@ const aiChemistryHelpHelper = {
      */
     async init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.info('[aiChemistryHelpHelper] Initialisierung gestartet');
+        this.adapter.log.info('[aiChemistryHelpHelper] initialization started');
 
         // NEU: auf Auswahländerungen reagieren
         this.adapter.subscribeStates('ai.chemistry_help.issue');
@@ -50,10 +50,10 @@ const aiChemistryHelpHelper = {
                 await this._processIssue(String(st.val));
             }
         } catch (e) {
-            this.adapter.log.debug(`[aiChemistryHelpHelper] Init: Konnte issue nicht lesen: ${e.message}`);
+            this.adapter.log.debug(`[aiChemistryHelpHelper] init: could not read issue: ${e.message}`);
         }
 
-        this.adapter.log.info('[aiChemistryHelpHelper] Initialisierung abgeschlossen');
+        this.adapter.log.info('[aiChemistryHelpHelper] initialization finished');
     },
 
     /**
@@ -61,7 +61,7 @@ const aiChemistryHelpHelper = {
      */
     cleanup() {
         // aktuell keine Timer / Intervalle
-        this.adapter && this.adapter.log.debug('[aiChemistryHelpHelper] Cleanup abgeschlossen');
+        this.adapter && this.adapter.log.debug('[aiChemistryHelpHelper] cleanup finished');
     },
 
     /**
@@ -101,12 +101,12 @@ const aiChemistryHelpHelper = {
                     issue = obj.common.states[state.val] || 'none';
                 }
             } catch (e) {
-                this.adapter.log.debug(`[aiChemistryHelpHelper] Konnte Enum-Text nicht auflösen: ${e.message}`);
+                this.adapter.log.debug(`[aiChemistryHelpHelper] could not resolve enum text: ${e.message}`);
             }
         } else {
             issue = String(state.val || 'none');
         }
-        this.adapter.log.debug(`[aiChemistryHelpHelper] Auswahl geändert: ${issue}`);
+        this.adapter.log.debug(`[aiChemistryHelpHelper] selection changed: ${issue}`);
 
         await this._processIssue(issue);
     },
@@ -384,7 +384,7 @@ const aiChemistryHelpHelper = {
 
             await this.adapter.setStateAsync(id, { val: value, ack: true });
         } catch (e) {
-            this.adapter.log.debug(`[aiChemistryHelpHelper] _setStateIfChanged Fehler (${id}): ${e.message}`);
+            this.adapter.log.debug(`[aiChemistryHelpHelper] _setStateIfChanged error (${id}): ${e.message}`);
         }
     },
 };

package/lib/helpers/aiForecastHelper.js

@@ -34,7 +34,7 @@ const aiForecastHelper = {
      */
     async init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.info('[aiForecastHelper] Initialisierung gestartet');
+        this.adapter.log.info('[aiForecastHelper] initialization started');
 
         await this._refreshTimer();
 
@@ -48,15 +48,15 @@ const aiForecastHelper = {
         // ----------------------------------------------------------
         const enabled = await this._getBool('ai.weather.switches.tomorrow_forecast_enabled', false);
         if (enabled) {
-            this.adapter.log.info('[aiForecastHelper] Starte einmalige Sofort-Vorhersage (Adapterstart)');
+            this.adapter.log.info('[aiForecastHelper] running one-time immediate forecast (adapter start)');
             try {
                 await this._runForecast();
             } catch (err) {
-                this.adapter.log.warn(`[aiForecastHelper] Fehler bei Sofort-Vorhersage: ${err.message}`);
+                this.adapter.log.warn(`[aiForecastHelper] error during immediate forecast: ${err.message}`);
             }
         }
 
-        this.adapter.log.info('[aiForecastHelper] Initialisierung abgeschlossen');
+        this.adapter.log.info('[aiForecastHelper] initialization finished');
     },
 
     /**
@@ -67,7 +67,7 @@ const aiForecastHelper = {
             clearInterval(this.timer);
             this.timer = null;
         }
-        this.adapter && this.adapter.log.debug('[aiForecastHelper] Cleanup abgeschlossen');
+        this.adapter && this.adapter.log.debug('[aiForecastHelper] cleanup finished');
     },
 
     /**
@@ -95,15 +95,15 @@ const aiForecastHelper = {
         // NEU: Sofortige Ausführung, wenn der Forecast aktiviert wird
         // ----------------------------------------------------------
         if (id.endsWith('ai.weather.switches.tomorrow_forecast_enabled') && state.val === true) {
-            this.adapter.log.info('[aiForecastHelper] Forecast aktiviert → einmalige sofortige Ausführung');
+            this.adapter.log.info('[aiForecastHelper] forecast enabled -> one-time immediate run');
             try {
                 await this._runForecast();
             } catch (err) {
-                this.adapter.log.warn(`[aiForecastHelper] Fehler bei Sofort-Ausführung: ${err.message}`);
+                this.adapter.log.warn(`[aiForecastHelper] error during immediate run: ${err.message}`);
             }
         }
 
-        this.adapter.log.info(`[aiForecastHelper] Änderung erkannt: ${id} = ${state.val}`);
+        this.adapter.log.info(`[aiForecastHelper] change detected: ${id} = ${state.val}`);
         await this._refreshTimer();
     },
 
@@ -121,14 +121,14 @@ const aiForecastHelper = {
         this._debugMode = await this._getBool('ai.weather.switches.debug_mode', false);
 
         if (!enabled) {
-            this.adapter.log.info('[aiForecastHelper] Forecast deaktiviert – kein Timer aktiv');
+            this.adapter.log.info('[aiForecastHelper] forecast disabled - no timer active');
             return;
         }
 
         const time = await this._getTimeOrDefault('ai.weather.schedule.tomorrow_forecast_time', '19:00');
 
         this.adapter.log.info(
-            `[aiForecastHelper] Forecast-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+            `[aiForecastHelper] forecast timer set for ${time.hour}:${String(time.minute).padStart(2, '0')}`,
         );
 
         // minütlicher Check
@@ -138,7 +138,7 @@ const aiForecastHelper = {
                 try {
                     await this._runForecast();
                 } catch (err) {
-                    this.adapter.log.warn(`[aiForecastHelper] Fehler im Timer: ${err.message}`);
+                    this.adapter.log.warn(`[aiForecastHelper] timer error: ${err.message}`);
                 }
             }
         }, 60 * 1000);
@@ -149,17 +149,17 @@ const aiForecastHelper = {
     // ---------------------------------------------------------------------
     async _runForecast() {
         try {
-            this.adapter.log.info('[aiForecastHelper] Erzeuge Vorhersage für morgen ...');
+            this.adapter.log.info('[aiForecastHelper] creating forecast for tomorrow ...');
 
             const geo = await this._loadGeoLocation();
             if (!geo) {
-                this.adapter.log.warn('[aiForecastHelper] Abbruch – keine Geodaten verfügbar');
+                this.adapter.log.warn('[aiForecastHelper] abort - no geo data available');
                 return;
             }
 
             const weather = await this._fetchWeather(geo.lat, geo.lon);
             if (!weather) {
-                this.adapter.log.warn('[aiForecastHelper] Abbruch – keine Wetterdaten');
+                this.adapter.log.warn('[aiForecastHelper] abort - no weather data available');
                 return;
             }
 
@@ -168,9 +168,9 @@ const aiForecastHelper = {
             await this._writeOutput('tomorrow_forecast', text);
             await this._maybeSpeak(text);
 
-            this.adapter.log.info('[aiForecastHelper] Vorhersage für morgen erzeugt');
+            this.adapter.log.info('[aiForecastHelper] forecast for tomorrow created');
         } catch (err) {
-            this.adapter.log.warn(`[aiForecastHelper] Fehler bei _runForecast(): ${err.message}`);
+            this.adapter.log.warn(`[aiForecastHelper] error in _runForecast(): ${err.message}`);
         }
     },
 
@@ -331,7 +331,7 @@ const aiForecastHelper = {
             `&timezone=auto`;
 
         if (this._debugMode) {
-            this.adapter.log.debug(`[aiForecastHelper] Abruf: ${url}`);
+            this.adapter.log.debug(`[aiForecastHelper] request: ${url}`);
         }
 
         return new Promise(resolve => {
@@ -363,10 +363,10 @@ const aiForecastHelper = {
             await this.adapter.setStateAsync(`ai.weather.outputs.${id}`, { val: text, ack: true });
 
             if (this._debugMode) {
-                this.adapter.log.debug(`[aiForecastHelper] Output geschrieben: ai.weather.outputs.${id}`);
+                this.adapter.log.debug(`[aiForecastHelper] output written: ai.weather.outputs.${id}`);
             }
         } catch (err) {
-            this.adapter.log.error(`[aiForecastHelper] Fehler beim Schreiben eines Outputs (${id}): ${err.message}`);
+            this.adapter.log.error(`[aiForecastHelper] error writing output (${id}): ${err.message}`);
         }
     },
 
@@ -378,9 +378,9 @@ const aiForecastHelper = {
 
         try {
             await this.adapter.setStateAsync('speech.queue', { val: text, ack: false });
-            this.adapter.log.info('[aiForecastHelper] Sprachausgabe gestartet');
+            this.adapter.log.info('[aiForecastHelper] speech output started');
         } catch (err) {
-            this.adapter.log.warn(`[aiForecastHelper] Fehler bei Sprachausgabe: ${err.message}`);
+            this.adapter.log.warn(`[aiForecastHelper] speech output error: ${err.message}`);
         }
     },
 

package/lib/helpers/aiHelper.js

@@ -61,12 +61,12 @@ const aiHelper = {
      */
     async init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.info('[aiHelper] Initialisierung gestartet');
+        this.adapter.log.info('[aiHelper] initialization started');
 
         // Ersten Settings-Load + Timeraufbau
         await this._refreshTimers();
 
-        this.adapter.log.info('[aiHelper] Initialisierung abgeschlossen');
+        this.adapter.log.info('[aiHelper] initialization finished');
     },
 
     /**
@@ -74,7 +74,7 @@ const aiHelper = {
      */
     cleanup() {
         this._clearTimers();
-        this.adapter && this.adapter.log.debug('[aiHelper] Cleanup abgeschlossen (Timer gestoppt)');
+        this.adapter && this.adapter.log.debug('[aiHelper] cleanup finished (timers stopped)');
     },
 
     /**
@@ -112,9 +112,7 @@ const aiHelper = {
             const oldVal = this._lastScheduleValues[id];
             const newVal = state.val;
 
-            this.adapter.log.info(
-                `[aiHelper] Uhrzeit geändert: ${id}: ${oldVal || '(kein vorheriger Wert)'} → ${newVal}`,
-            );
+            this.adapter.log.info(`[aiHelper] time changed: ${id}: ${oldVal || '(no previous value)'} -> ${newVal}`);
 
             // neuen Wert speichern
             this._lastScheduleValues[id] = newVal;
@@ -141,7 +139,7 @@ const aiHelper = {
                     // Nur wenn Zielzeit HEUTE noch bevorsteht
                     if (target > now) {
                         this.adapter.log.info(
-                            `[aiHelper] Neue Uhrzeit liegt heute noch in der Zukunft → führe Modul sofort aus (${id})`,
+                            `[aiHelper] new time is still in the future today -> running module immediately (${id})`,
                         );
 
                         if (id.endsWith('weather_advice_time')) {
@@ -159,7 +157,7 @@ const aiHelper = {
                     }
                 }
             } catch (e) {
-                this.adapter.log.warn(`[aiHelper] Fehler bei Sofortausführung nach Zeitänderung: ${e.message}`);
+                this.adapter.log.warn(`[aiHelper] error during immediate run after time change: ${e.message}`);
             }
 
             return;
@@ -169,7 +167,7 @@ const aiHelper = {
         // FIX 3: Schalteränderungen immer melden
         // ---------------------------------------------------------
         if (id.includes('.ai.weather.switches.')) {
-            this.adapter.log.info(`[aiHelper] Schalter geändert: ${id} = ${state.val} – Timer werden neu aufgebaut`);
+            this.adapter.log.info(`[aiHelper] switch changed: ${id} = ${state.val} - rebuilding timers`);
 
             await this._refreshTimers();
             return;
@@ -200,11 +198,11 @@ const aiHelper = {
         this._debugMode = await this._getBool('ai.weather.switches.debug_mode', false);
 
         if (!aiEnabled) {
-            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.enabled = false) – keine Timer aktiv');
+            this.adapter.log.info('[aiHelper] AI is disabled (ai.enabled = false) - no timers active');
             return;
         }
 
-        this.adapter.log.info('[aiHelper] KI ist aktiv – Timer werden gesetzt');
+        this.adapter.log.info('[aiHelper] AI is enabled - setting timers');
 
         // --- Wetterhinweise ---
         const weatherEnabled = await this._getBool('ai.weather.switches.weather_advice_enabled', false);
@@ -214,7 +212,7 @@ const aiHelper = {
                 await this._runWeatherAdvice();
             });
             this.adapter.log.debug(
-                `[aiHelper] Wetterhinweis-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+                `[aiHelper] weather advice timer set for ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
@@ -226,7 +224,7 @@ const aiHelper = {
                 await this._runDailySummary();
             });
             this.adapter.log.debug(
-                `[aiHelper] Daily-Summary-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+                `[aiHelper] daily summary timer set for ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
@@ -238,7 +236,7 @@ const aiHelper = {
                 await this._runDailyPoolTips();
             });
             this.adapter.log.debug(
-                `[aiHelper] Pool-Tipps-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+                `[aiHelper] pool tips timer set for ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
@@ -250,27 +248,27 @@ const aiHelper = {
                 await this._runWeekendSummary();
             });
             this.adapter.log.debug(
-                `[aiHelper] Wochenend-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
+                `[aiHelper] weekend summary timer set for ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         //--------------------------------------------------------
         // NEU: Stündlicher Wetter-Update-Timer
         //--------------------------------------------------------
-        this.adapter.log.debug('[aiHelper] Stündlicher Wetter-Update-Timer wird gesetzt');
+        this.adapter.log.debug('[aiHelper] setting hourly weather update timer');
 
         const hourlyTimer = setInterval(
             async () => {
                 try {
                     const geo = await this._loadGeoLocation();
                     if (!geo) {
-                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Geodaten verfügbar');
+                        this.adapter.log.info('[aiHelper] weather update aborted - no geo data available');
                         return;
                     }
 
                     const weather = await this._fetchWeather(geo.lat, geo.lon);
                     if (!weather) {
-                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Wetterdaten verfügbar');
+                        this.adapter.log.info('[aiHelper] weather update aborted - no weather data available');
                         return;
                     }
 
@@ -284,12 +282,10 @@ const aiHelper = {
                     await this._writeOutput('pool_tips', poolTipsText);
 
                     if (this._debugMode) {
-                        this.adapter.log.debug(
-                            '[aiHelper] Stündliches Wetter-Update durchgeführt (Weather + Pool-Tipps)',
-                        );
+                        this.adapter.log.debug('[aiHelper] hourly weather update completed (weather + pool tips)');
                     }
                 } catch (err) {
-                    this.adapter.log.warn(`[aiHelper] Fehler beim stündlichen Wetter-Update: ${err.message}`);
+                    this.adapter.log.warn(`[aiHelper] error during hourly weather update: ${err.message}`);
                 }
             },
             60 * 60 * 1000,
@@ -319,23 +315,21 @@ const aiHelper = {
             if (withinStartupWindow && diffMinutes > 0 && diffMinutes <= 2) {
                 try {
                     await callback();
-                    this.adapter.log.info(
-                        '[aiHelper] Nachholung ausgeführt (innerhalb der ersten 3 Minuten nach Start)',
-                    );
+                    this.adapter.log.info('[aiHelper] catch-up executed (within the first 3 minutes after start)');
                 } catch (err) {
-                    this.adapter.log.warn(`[aiHelper] Fehler bei Nachholung: ${err.message}`);
+                    this.adapter.log.warn(`[aiHelper] catch-up error: ${err.message}`);
                 }
             }
 
             if (now.getHours() === hour && now.getMinutes() === minute) {
                 this.adapter.log.debug(
-                    `[aiHelper] Timer ausgelöst: ${hour}:${String(minute).padStart(2, '0')} → Callback wird ausgeführt`,
+                    `[aiHelper] timer triggered: ${hour}:${String(minute).padStart(2, '0')} -> running callback`,
                 ); // NEU
 
                 try {
                     await callback();
                 } catch (err) {
-                    this.adapter.log.warn(`[aiHelper] Fehler im Timer-Callback: ${err.message}`);
+                    this.adapter.log.warn(`[aiHelper] timer callback error: ${err.message}`);
                 }
             }
         }, 60 * 1000); // jede Minute prüfen
@@ -354,13 +348,13 @@ const aiHelper = {
         try {
             const geo = await this._loadGeoLocation();
             if (!geo) {
-                this.adapter.log.info('[aiHelper] Wetterhinweis abgebrochen – keine Geodaten verfügbar');
+                this.adapter.log.info('[aiHelper] weather advice aborted - no geo data available');
                 return;
             }
 
             const weather = await this._fetchWeather(geo.lat, geo.lon);
             if (!weather) {
-                this.adapter.log.info('[aiHelper] Wetterhinweis abgebrochen – keine Wetterdaten');
+                this.adapter.log.info('[aiHelper] weather advice aborted - no weather data available');
                 return;
             }
 
@@ -368,9 +362,9 @@ const aiHelper = {
             await this._writeOutput('weather_advice', text);
             await this._maybeSpeak(text);
 
-            this.adapter.log.info('[aiHelper] Neuer Wetterhinweis erzeugt');
+            this.adapter.log.info('[aiHelper] new weather advice created');
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei _runWeatherAdvice(): ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] error in _runWeatherAdvice(): ${err.message}`);
         }
     },
 
@@ -398,9 +392,9 @@ const aiHelper = {
             await this._writeOutput('daily_summary', text);
             await this._maybeSpeak(text);
 
-            this.adapter.log.info('[aiHelper] Neue Tageszusammenfassung erzeugt');
+            this.adapter.log.info('[aiHelper] new daily summary created');
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei _runDailySummary(): ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] error in _runDailySummary(): ${err.message}`);
         }
     },
 
@@ -418,9 +412,9 @@ const aiHelper = {
             await this._writeOutput('pool_tips', text);
             await this._maybeSpeak(text);
 
-            this.adapter.log.info('[aiHelper] Neue Pool-Tipps erzeugt');
+            this.adapter.log.info('[aiHelper] new pool tips created');
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei _runDailyPoolTips(): ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] error in _runDailyPoolTips(): ${err.message}`);
         }
     },
 
@@ -434,9 +428,7 @@ const aiHelper = {
 
             // Nur Freitag oder Samstag sinnvoll
             if (weekday !== 5 && weekday !== 6) {
-                this.adapter.log.info(
-                    '[aiHelper] Wochenend-Zusammenfassung übersprungen – heute ist weder Freitag noch Samstag',
-                );
+                this.adapter.log.info('[aiHelper] weekend summary skipped - today is neither Friday nor Saturday');
                 return;
             }
 
@@ -449,9 +441,9 @@ const aiHelper = {
             await this._writeOutput('weekend_summary', text);
             await this._maybeSpeak(text);
 
-            this.adapter.log.info('[aiHelper] Neue Wochenend-Zusammenfassung erzeugt');
+            this.adapter.log.info('[aiHelper] new weekend summary created');
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei _runWeekendSummary(): ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] error in _runWeekendSummary(): ${err.message}`);
         }
     },
 
@@ -462,13 +454,13 @@ const aiHelper = {
         try {
             const geo = await this._loadGeoLocation();
             if (!geo) {
-                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Geodaten verfügbar');
+                this.adapter.log.info('[aiHelper] auto weather update aborted - no geo data available');
                 return;
             }
 
             const weather = await this._fetchWeather(geo.lat, geo.lon);
             if (!weather) {
-                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Wetterdaten verfügbar');
+                this.adapter.log.info('[aiHelper] auto weather update aborted - no weather data available');
                 return;
             }
 
@@ -477,10 +469,10 @@ const aiHelper = {
             await this._writeOutput('weather_advice', text);
 
             if (this._debugMode) {
-                this.adapter.log.debug('[aiHelper] Auto-Wetterupdate erfolgreich durchgeführt');
+                this.adapter.log.debug('[aiHelper] auto weather update completed successfully');
             }
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei Auto-Wetterupdate: ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] error during auto weather update: ${err.message}`);
         }
     },
 
@@ -497,7 +489,7 @@ const aiHelper = {
         try {
             const obj = await this.adapter.getForeignObjectAsync('system.config');
             if (!obj || !obj.common) {
-                this.adapter.log.warn('[aiHelper] Konnte system.config nicht laden');
+                this.adapter.log.warn('[aiHelper] could not load system.config');
                 return null;
             }
 
@@ -505,17 +497,17 @@ const aiHelper = {
             const lon = Number(obj.common.longitude);
 
             if (Number.isNaN(lat) || Number.isNaN(lon)) {
-                this.adapter.log.warn('[aiHelper] Geodaten ungültig – bitte in Admin unter System/Standort eintragen');
+                this.adapter.log.warn('[aiHelper] invalid geo data - please set it in Admin under System/Location');
                 return null;
             }
 
             if (this._debugMode) {
-                this.adapter.log.debug(`[aiHelper] Geodaten geladen: lat=${lat}, lon=${lon}`);
+                this.adapter.log.debug(`[aiHelper] geo data loaded: lat=${lat}, lon=${lon}`);
             }
 
             return { lat, lon };
         } catch (err) {
-            this.adapter.log.error(`[aiHelper] Fehler beim Laden der Geodaten: ${err.message}`);
+            this.adapter.log.error(`[aiHelper] error loading geo data: ${err.message}`);
             return null;
         }
     },
@@ -537,7 +529,7 @@ const aiHelper = {
             `&timezone=auto`;
 
         if (this._debugMode) {
-            this.adapter.log.debug(`[aiHelper] Rufe Wetterdaten ab: ${url}`);
+            this.adapter.log.debug(`[aiHelper] fetching weather data: ${url}`);
         }
 
         return new Promise(resolve => {
@@ -551,23 +543,23 @@ const aiHelper = {
                         res.on('end', () => {
                             try {
                                 if (!data) {
-                                    this.adapter.log.warn('[aiHelper] Wetterabfrage: leere Antwort erhalten');
+                                    this.adapter.log.warn('[aiHelper] weather request: received empty response');
                                     return resolve(null);
                                 }
                                 const json = JSON.parse(data);
                                 resolve(json);
                             } catch (err) {
-                                this.adapter.log.warn(`[aiHelper] Fehler beim Parsen der Wetterdaten: ${err.message}`);
+                                this.adapter.log.warn(`[aiHelper] error parsing weather data: ${err.message}`);
                                 resolve(null);
                             }
                         });
                     })
                     .on('error', err => {
-                        this.adapter.log.warn(`[aiHelper] Fehler bei Wetterabfrage: ${err.message}`);
+                        this.adapter.log.warn(`[aiHelper] weather request error: ${err.message}`);
                         resolve(null);
                     });
             } catch (err) {
-                this.adapter.log.warn(`[aiHelper] Unerwarteter Fehler bei Wetterabfrage: ${err.message}`);
+                this.adapter.log.warn(`[aiHelper] unexpected weather request error: ${err.message}`);
                 resolve(null);
             }
         });
@@ -975,10 +967,10 @@ const aiHelper = {
             await this.adapter.setStateAsync('ai.weather.outputs.last_message', { val: text, ack: true });
 
             if (this._debugMode) {
-                this.adapter.log.debug(`[aiHelper] Output geschrieben → ai.weather.outputs.${id}: ${text}`);
+                this.adapter.log.debug(`[aiHelper] output written -> ai.weather.outputs.${id}: ${text}`);
             }
         } catch (err) {
-            this.adapter.log.error(`[aiHelper] Fehler beim Schreiben eines Outputs (${id}): ${err.message}`);
+            this.adapter.log.error(`[aiHelper] error writing output (${id}): ${err.message}`);
         }
     },
 
@@ -998,18 +990,16 @@ const aiHelper = {
         const allowSpeech = await this._getBool('ai.weather.switches.allow_speech', false);
         if (!allowSpeech) {
             if (this._debugMode) {
-                this.adapter.log.debug(
-                    '[aiHelper] Sprachausgabe deaktiviert (ai.weather.switches.allow_speech = false)',
-                );
+                this.adapter.log.debug('[aiHelper] speech output disabled (ai.weather.switches.allow_speech = false)');
             }
             return;
         }
 
         try {
             await this.adapter.setStateAsync('speech.queue', { val: text, ack: false });
-            this.adapter.log.info('[aiHelper] Text an speech.queue übergeben');
+            this.adapter.log.info('[aiHelper] text sent to speech.queue');
         } catch (err) {
-            this.adapter.log.warn(`[aiHelper] Fehler bei Sprachausgabe: ${err.message}`);
+            this.adapter.log.warn(`[aiHelper] speech output error: ${err.message}`);
         }
     },
 
@@ -1082,14 +1072,14 @@ const aiHelper = {
         const str = await this._getString(id, def);
 
         // NEU: Log, welche Uhrzeit der Helper tatsächlich verwendet
-        this.adapter.log.debug(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
+        this.adapter.log.debug(`[aiHelper] time loaded: ${id} = "${str}" (default: ${def})`);
 
         const match = /^(\d{1,2}):(\d{2})$/.exec(str || '');
         let hour = 0;
         let minute = 0;
 
         if (!match) {
-            this.adapter.log.warn(`[aiHelper] Ungültiges Zeitformat in ${id}: "${str}" – verwende Default ${def}`);
+            this.adapter.log.warn(`[aiHelper] invalid time format in ${id}: "${str}" - using default ${def}`);
             const defMatch = /^(\d{1,2}):(\d{2})$/.exec(def);
             if (defMatch) {
                 hour = Number(defMatch[1]);