smartplant 0.1.6 → 0.2.0

package/src/language/messages-pt.js

@@ -0,0 +1,42 @@
+export default {
+	'general' : {
+		'welcome'            : 'Bem-vindo ao SmartPlant!',
+		'selectInputMethod'  : 'Selecione o método de entrada:',
+		'local'              : 'Local',
+		'external'           : 'Externo',
+		'localSelected'      : 'Método local selecionado.',
+		'externSelected'     : 'Método externo selecionado.',
+		'selectAIModel'      : 'Selecione um modelo de IA local:',
+		'selectedAIModel'    : 'Modelo de IA selecionado: {model}',
+		'noLocalAI'          : 'Nenhum modelo de IA local detectado.',
+		'enterAPIKey'        : 'Digite sua chave API:',
+		'invalidMethod'      : 'Método selecionado inválido.',
+		'selectPlantType'    : 'Você tem uma planta de interior ou de exterior?',
+		'indoor'             : 'Interior',
+		'outdoor'            : 'Exterior',
+		'invalidType'        : 'Tipo de planta selecionado inválido.',
+		'enterPlantName'     : 'Digite o nome da planta:',
+		'plantNameSet'       : 'Nome da planta definido como: {name}',
+		'settingUpSensors'   : 'Configurando sensores...',
+		'sensorsReady'       : 'Sensores prontos!',
+		'alertsConfigured'   : 'Alertas configurados.',
+		'alertsActivated'    : 'Alertas ativados.',
+		'startingMonitoring' : 'Iniciando o monitoramento da planta...',
+		'checkingStatus'     : 'Verificando o status da planta...',
+	},
+	'alerts' : {
+		'moisture' : {
+			'low'  : 'Aviso: Umidade do solo baixa ({value}%).',
+			'high' : 'Aviso: Umidade do solo alta ({value}%).',
+		},
+		'light' : {
+			'low'  : 'Aviso: Nível de luz baixo ({value} lux).',
+			'high' : 'Aviso: Nível de luz alto ({value} lux).',
+		},
+		'temperature' : {
+			'low'  : 'Aviso: Temperatura baixa ({value}°C).',
+			'high' : 'Aviso: Temperatura alta ({value}°C).',
+		},
+	},
+}
+  

package/src/language/messages-ru.js

@@ -0,0 +1,42 @@
+export default {
+	'general' : {
+		'welcome'            : 'Добро пожаловать в SmartPlant!',
+		'selectInputMethod'  : 'Выберите метод ввода:',
+		'local'              : 'Локально',
+		'external'           : 'Внешне',
+		'localSelected'      : 'Выбран локальный метод.',
+		'externSelected'     : 'Выбран внешний метод.',
+		'selectAIModel'      : 'Выберите локальную модель ИИ:',
+		'selectedAIModel'    : 'Выбранная модель ИИ: {model}',
+		'noLocalAI'          : 'Локальные модели ИИ не обнаружены.',
+		'enterAPIKey'        : 'Введите ваш API-ключ:',
+		'invalidMethod'      : 'Выбранный метод недействителен.',
+		'selectPlantType'    : 'У вас есть растение для помещений или на улице?',
+		'indoor'             : 'Для помещений',
+		'outdoor'            : 'На улице',
+		'invalidType'        : 'Выбранный тип растения недействителен.',
+		'enterPlantName'     : 'Введите имя растения:',
+		'plantNameSet'       : 'Имя растения установлено на: {name}',
+		'settingUpSensors'   : 'Настройка датчиков...',
+		'sensorsReady'       : 'Датчики готовы!',
+		'alertsConfigured'   : 'Настроены предупреждения.',
+		'alertsActivated'    : 'Предупреждения активированы.',
+		'startingMonitoring' : 'Запуск мониторинга растений...',
+		'checkingStatus'     : 'Проверка состояния растения...',
+	},
+	'alerts' : {
+		'moisture' : {
+			'low'  : 'Предупреждение: Влажность почвы низкая ({value}%).',
+			'high' : 'Предупреждение: Влажность почвы высокая ({value}%).',
+		},
+		'light' : {
+			'low'  : 'Предупреждение: Уровень света низкий ({value} lux).',
+			'high' : 'Предупреждение: Уровень света высокий ({value} lux).',
+		},
+		'temperature' : {
+			'low'  : 'Предупреждение: Температура низкая ({value}°C).',
+			'high' : 'Предупреждение: Температура высокая ({value}°C).',
+		},
+	},
+}
+  

package/src/language/messages-zh.js

@@ -0,0 +1,42 @@
+export default {
+	'general' : {
+		'welcome'            : '欢迎使用 SmartPlant！',
+		'selectInputMethod'  : '选择输入方法：',
+		'local'              : '本地',
+		'external'           : '外部',
+		'localSelected'      : '已选择本地方法。',
+		'externSelected'     : '已选择外部方法。',
+		'selectAIModel'      : '选择本地 AI 模型：',
+		'selectedAIModel'    : '选择的 AI 模型：{model}',
+		'noLocalAI'          : '未检测到本地 AI 模型。',
+		'enterAPIKey'        : '输入您的 API 密钥：',
+		'invalidMethod'      : '选择的方法无效。',
+		'selectPlantType'    : '您的植物是室内植物还是户外植物？',
+		'indoor'             : '室内',
+		'outdoor'            : '户外',
+		'invalidType'        : '选择的植物类型无效。',
+		'enterPlantName'     : '输入植物的名称：',
+		'plantNameSet'       : '植物名称设置为：{name}',
+		'settingUpSensors'   : '设置传感器中...',
+		'sensorsReady'       : '传感器已准备好！',
+		'alertsConfigured'   : '警报已配置。',
+		'alertsActivated'    : '警报已激活。',
+		'startingMonitoring' : '开始植物监控...',
+		'checkingStatus'     : '检查植物状态...',
+	},
+	'alerts' : {
+		'moisture' : {
+			'low'  : '警告：土壤湿度低 ({value}%)。',
+			'high' : '警告：土壤湿度高 ({value}%)。',
+		},
+		'light' : {
+			'low'  : '警告：光线水平低 ({value} lux)。',
+			'high' : '警告：光线水平高 ({value} lux)。',
+		},
+		'temperature' : {
+			'low'  : '警告：温度低 ({value}°C)。',
+			'high' : '警告：温度高 ({value}°C)。',
+		},
+	},
+}
+  

package/src/main.js

@@ -0,0 +1,436 @@
+import { ReadlineParser } from '@serialport/parser-readline';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import { execSync } from 'node:child_process';
+import { SerialPort } from 'serialport';
+
+import MsgDe from './language/messages-de.js';
+import MsgEn from './language/messages-en.js';
+import MsgEs from './language/messages-es.js';
+import MsgFr from './language/messages-fr.js';
+import MsgIt from './language/messages-it.js';
+import MsgJa from './language/messages-ja.js';
+import MsgPt from './language/messages-pt.js';
+import MsgRu from './language/messages-ru.js';
+import MsgZh from './language/messages-zh.js';
+
+const messagesMap = { de: MsgDe, en: MsgEn, es: MsgEs, fr: MsgFr, ja: MsgJa, it: MsgIt, pt: MsgPt, ru: MsgRu, zh: MsgZh };
+
+function loadMessages(lang) {
+  return messagesMap[lang] || MsgEn;
+}
+
+class AIService {
+  constructor(provider, apiKey = null, localModel = null) {
+    this.provider = provider;
+    this.apiKey = apiKey;
+    this.localModel = localModel;
+  }
+
+  async generateResponse(prompt, language) {
+    const fullPrompt = `Responde en ${language}. ${prompt}`;
+    try {
+      switch (this.provider) {
+        case 'openai': return this._openAICompatible(fullPrompt, 'https://api.openai.com/v1/chat/completions', 'gpt-4o-mini');
+        case 'grok':   return this._openAICompatible(fullPrompt, 'https://api.x.ai/v1/chat/completions', 'grok-beta');
+        case 'claude': return this._claude(fullPrompt);
+        case 'gemini': return this._gemini(fullPrompt);
+        case 'local':  return this._ollama(fullPrompt);
+        default: throw new Error('Proveedor no soportado');
+      }
+    } catch (err) {
+      console.error(chalk.red(`Error en ${this.provider}:`), err.message);
+      return null;
+    }
+  }
+
+  async _openAICompatible(prompt, url, model) {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }], max_tokens: 600, temperature: 0.7 }),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    return data.choices[0].message.content.trim();
+  }
+
+  async _claude(prompt) {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: { 'x-api-key': this.apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: 'claude-3-5-sonnet-20241022', max_tokens: 600, messages: [{ role: 'user', content: prompt }] }),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    return data.content[0].text.trim();
+  }
+
+  async _gemini(prompt) {
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${this.apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ contents: [{ parts: [{ text: prompt }] }] }),
+    });
+    if (!res.ok) {
+      if (res.status === 429) throw new Error('429 - Límite de Gemini alcanzado. Espera 60 segundos.');
+      if (res.status === 404) throw new Error('404 - Modelo Gemini no encontrado. Usa OpenAI o Grok.');
+      throw new Error(`HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    return data.candidates[0].content.parts[0].text.trim();
+  }
+
+  async _ollama(prompt) {
+    const cmd = `ollama run ${this.localModel} "${prompt.replace(/"/g, '\\"').replace(/\n/g, ' ')}"`;
+    const out = execSync(cmd, { encoding: 'utf-8' });
+    return out.trim();
+  }
+}
+
+export class SmartPlant {
+  constructor() {
+    this.language = 'en';
+    this.messages = null;
+    this.platform = null;
+    this.aiClient = null;
+    this.plantName = '';
+    this.plantType = null;
+    this.plantInfo = null;
+    this.alerts = {};
+    this.sensors = { humidity: null, light: null, temperature: null };
+    this.historicalData = [];
+    this.isMonitoring = false;
+    this.hibernationMode = false;
+    this.hasSensors = false;
+    this.serialPort = null;
+    this.monitoringInterval = null;
+  }
+
+  async init() { this.messages = loadMessages(this.language); }
+
+  async setLanguage(lang) {
+    this.language = lang;
+    this.messages = loadMessages(lang);
+  }
+
+  welcome() {
+    console.log('\n' + chalk.bold(this.messages.general.welcome) + '\n');
+  }
+
+  async start() {
+    await this.init();
+    this.welcome();
+    await this.selectLanguage();
+    await this.selectPlatform();
+    await this.selectAIMethod();
+    console.log();
+    await this.selectPlantType();
+    await this.setPlantName();
+    await this.generatePlantInfo();
+    await this.setupSensors();
+    this.setupAlerts();
+    this.startMonitoring();
+  }
+
+  async selectLanguage() {
+    const { language } = await enquirer.prompt({
+      type: 'autocomplete',
+      name: 'language',
+      message: 'Select language:',
+      choices: [
+        { name: 'English', value: 'en' }, { name: 'Español', value: 'es' },
+        { name: 'Français', value: 'fr' }, { name: 'Deutsch', value: 'de' },
+        { name: 'Italiano', value: 'it' }, { name: 'Português', value: 'pt' },
+        { name: 'Nederlands', value: 'nl' }, { name: 'Русский', value: 'ru' },
+        { name: '中文', value: 'zh' }, { name: '日本語', value: 'ja' },
+      ],
+    });
+    await this.setLanguage(language);
+  }
+
+  async selectPlatform() {
+    const { platform } = await enquirer.prompt({
+      type: 'select',
+      name: 'platform',
+      message: this.messages.general.selectPlatform,
+      choices: [
+        { name: 'Raspberry Pi', value: 'raspberry' },
+        { name: 'Arduino', value: 'arduino' },
+      ],
+    });
+    this.platform = platform;
+    await this.setupPlatform();
+  }
+
+  async setupPlatform() {
+    if (this.platform === 'raspberry') {
+      console.log(chalk.bold('Setting up Raspberry Pi...'));
+      this.hasSensors = true;
+    } else if (this.platform === 'arduino') {
+      console.log(chalk.bold('Setting up Arduino...'));
+      this.serialPort = new SerialPort({ path: '/dev/ttyACM0', baudRate: 9600 });
+      this.serialPort.pipe(new ReadlineParser({ delimiter: '\r\n' })).on('data', data => this.handleArduinoData(data));
+      console.log('Arduino setup complete. Upload arduino_dht22.ino first.');
+      this.hasSensors = true;
+    }
+  }
+
+  handleArduinoData(data) {
+    const [temperature, humidity, light] = data.split(',').map(Number);
+    this.sensors.temperature = temperature;
+    this.sensors.humidity = humidity;
+    this.sensors.light = light;
+    this.checkAlerts();
+  }
+
+  async selectAIMethod() {
+    const { provider } = await enquirer.prompt({
+      type: 'select',
+      name: 'provider',
+      message: 'Elige proveedor de IA:',
+      choices: [
+        { message: 'OpenAI (GPT-4o-mini)', value: 'openai' },
+        { message: 'Grok (xAI)', value: 'grok' },
+        { message: 'Claude (Anthropic)', value: 'claude' },
+        { message: 'Gemini (Google)', value: 'gemini' },
+        { message: 'Local (Ollama)', value: 'local' },
+      ],
+    });
+
+    let apiKey = null;
+    let localModel = null;
+
+    if (provider !== 'local') {
+      const { key } = await enquirer.prompt({
+        type: 'password',
+        name: 'key',
+        message: `Introduce tu API key de ${provider.toUpperCase()}:`,
+      });
+      apiKey = key;
+    } else {
+      localModel = await this.selectLocalModel();
+    }
+
+    this.aiClient = new AIService(provider, apiKey, localModel);
+    console.log(chalk.green('✅ IA conectada correctamente! 🤖✨'));
+  }
+
+  async selectLocalModel() {
+    try {
+      const output = execSync('ollama list', { encoding: 'utf-8' });
+      const models = output.split('\n').filter(l => l.trim() && !l.startsWith('NAME')).map(l => l.split(' ')[0]);
+      if (models.length === 0) throw new Error();
+      const { model } = await enquirer.prompt({
+        type: 'select',
+        name: 'model',
+        message: 'Selecciona modelo local:',
+        choices: models,
+      });
+      return model;
+    } catch {
+      console.log(chalk.yellow('No se encontraron modelos Ollama.'));
+      process.exit(0);
+    }
+  }
+
+  async selectPlantType() {
+    const { type } = await enquirer.prompt({
+      type: 'select',
+      name: 'type',
+      message: this.messages.general.selectPlantType,
+      choices: [
+        { name: this.messages.general.indoor, value: 'indoor' },
+        { name: this.messages.general.outdoor, value: 'outdoor' },
+      ],
+    });
+    this.plantType = type;
+  }
+
+  async setPlantName() {
+    const { name } = await enquirer.prompt({
+      type: 'input',
+      name: 'name',
+      message: this.messages.general.enterPlantName,
+    });
+    this.plantName = name;
+  }
+
+  async generatePlantInfo() {
+    console.log(chalk.bold('🔍🌿 Generando información de la planta...'));
+    const prompt = `Provide a comprehensive summary for ${this.plantName} (${this.plantType}) including: Lighting, Watering, Temperature, Humidity, Soil, Fertilization, Pruning, and Propagation. Also give ranges in format: "Lighting: X-Y lux, Temperature: A-B°C, Humidity: C-D%".`;
+    const response = await this.aiClient.generateResponse(prompt, this.language);
+    if (!response) {
+      console.log(chalk.red('❌ No se pudo generar la información de la planta.'));
+      return;
+    }
+
+    const lightingMatch = response.match(/Lighting:\s*(\d+)-(\d+)\s*lux/i);
+    const tempMatch = response.match(/Temperature:\s*(\d+)-(\d+)\s*°C/i);
+    const humMatch = response.match(/Humidity:\s*(\d+)-(\d+)%/i);
+
+    this.plantInfo = {
+      summary: response,
+      lighting: lightingMatch ? { min: +lightingMatch[1], max: +lightingMatch[2] } : { min: 50, max: 700 },
+      temperature: tempMatch ? { min: +tempMatch[1], max: +tempMatch[2] } : { min: 18, max: 24 },
+      humidity: humMatch ? { min: +humMatch[1], max: +humMatch[2] } : { min: 40, max: 60 },
+    };
+    console.log(chalk.green('✅ Información de planta generada!'));
+  }
+
+  async setupSensors() {
+    console.log(chalk.bold(this.messages.general.settingUpSensors));
+    if (!this.hasSensors) console.log(chalk.yellow('Modo simulación activado.'));
+    console.log(chalk.bold(this.messages.general.sensorsReady));
+  }
+
+  setupAlerts() {
+    if (!this.plantInfo) return;
+    this.alerts = {
+      humidity: { min: this.plantInfo.humidity.min, max: this.plantInfo.humidity.max },
+      light: { min: this.plantInfo.lighting.min, max: this.plantInfo.lighting.max },
+      temperature: { min: this.plantInfo.temperature.min, max: this.plantInfo.temperature.max },
+    };
+    if (this.messages.general.alertsSet) console.log(this.messages.general.alertsSet);
+  }
+
+  calculatePercentage(v, min, max) {
+    if (!v || isNaN(v)) return 0;
+    return Math.min(Math.max(((v - min) / (max - min)) * 100, 0), 100);
+  }
+
+  getHumidityEmoji(p) { if (p <= 0) return '🍂'; if (p <= 30) return '🍂'; if (p <= 60) return '🌿'; if (p <= 80) return '💧'; return '🌊'; }
+  getLightEmoji(p) { if (p <= 0) return '🌑'; if (p <= 30) return '🌑'; if (p <= 60) return '🌥'; return '🌞'; }
+  getTemperatureEmoji(p) { if (p <= 0) return '🧊'; if (p <= 30) return '🧊'; if (p <= 80) return '🌡️'; return '🔥'; }
+  getHappinessEmoji(avg) {
+    if (avg <= 0) return '😵';
+    if (avg >= 90) return '🤩';
+    if (avg >= 75) return '😊';
+    if (avg >= 60) return '😐';
+    if (avg >= 45) return '😞';
+    if (avg >= 30) return '😖';
+    return '🥵';
+  }
+
+  logPlantStatus() {
+    const allSensorsZero = Object.values(this.sensors).every(value => value === 0 || value === null || value === undefined);
+    if (!this.hasSensors || allSensorsZero) {
+      console.log(chalk.yellow('🔔 Warning: No data input or sensors are disconnected.'));
+      console.log('😵 | Lighting: 🌑 (0%) | Temperature: 🧊 (0.0°C) | Humidity: 🍂 (0%)');
+      return;
+    }
+
+    const humidityPercentage = this.calculatePercentage(this.sensors.humidity, this.alerts.humidity.min, this.alerts.humidity.max);
+    const lightPercentage = this.calculatePercentage(this.sensors.light, this.alerts.light.min, this.alerts.light.max);
+    const temperaturePercentage = this.calculatePercentage(this.sensors.temperature, this.alerts.temperature.min, this.alerts.temperature.max);
+    const averagePercentage = (humidityPercentage + lightPercentage + temperaturePercentage) / 3;
+
+    const happinessEmoji = this.getHappinessEmoji(averagePercentage);
+    const humidityEmoji = this.getHumidityEmoji(humidityPercentage);
+    const lightEmoji = this.getLightEmoji(lightPercentage);
+    const temperatureEmoji = this.getTemperatureEmoji(temperaturePercentage);
+
+    const status = `${happinessEmoji} | Lighting: ${lightEmoji} (${lightPercentage.toFixed(0)}%) | Temperature: ${temperatureEmoji} (${this.sensors.temperature?.toFixed(1) || 0.0}°C) | Humidity: ${humidityEmoji} (${humidityPercentage.toFixed(0)}%)`;
+    console.log(status);
+
+    this.historicalData.push({ timestamp: new Date(), humidity: this.sensors.humidity, light: this.sensors.light, temperature: this.sensors.temperature });
+    this.predictCriticalState();
+  }
+
+  predictCriticalState() {
+    if (this.historicalData.length < 10) return;
+    const recentData = this.historicalData.slice(-10);
+    const trends = {
+      humidity: this.calculateTrend(recentData.map(d => d.humidity)),
+      light: this.calculateTrend(recentData.map(d => d.light)),
+      temperature: this.calculateTrend(recentData.map(d => d.temperature)),
+    };
+    for (const [sensor, trend] of Object.entries(trends)) {
+      if (Math.abs(trend) > 0.5) {
+        const direction = trend > 0 ? 'increasing' : 'decreasing';
+        console.log(chalk.yellow.bold(`🔔 Warning: ${sensor} is ${direction} rapidly. Consider taking action.`));
+      }
+    }
+  }
+
+  calculateTrend(data) {
+    const n = data.length;
+    const sum_x = n * (n + 1) / 2;
+    const sum_y = data.reduce((a, b) => a + b, 0);
+    const sum_xy = data.reduce((sum, y, i) => sum + y * (i + 1), 0);
+    const sum_xx = n * (n + 1) * (2 * n + 1) / 6;
+    return (n * sum_xy - sum_x * sum_y) / (n * sum_xx - sum_x * sum_x);
+  }
+
+  startMonitoring() {
+    console.log(this.messages.general.startMonitoring || 'Monitoreo iniciado...');
+    this.isMonitoring = true;
+    this.monitoringInterval = setInterval(() => {
+      if (!this.hibernationMode) this.logPlantStatus();
+    }, 60000);
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', key => {
+      if (key === '\u0003') process.exit();
+      if (key === '\u000F') this.pauseMonitoring();
+    });
+  }
+
+  pauseMonitoring() {
+    clearInterval(this.monitoringInterval);
+    this.isMonitoring = false;
+    this.displaySensorSettingsMenu();
+  }
+
+  async displaySensorSettingsMenu() {
+    const choices = ['Ajustar configuración de sensores', 'Activar/Desactivar modo de hibernación', 'Volver a iniciar monitoreo', 'Salir'];
+    const { option } = await enquirer.prompt({ type: 'select', name: 'option', message: 'Monitoreo detenido. ¿Qué deseas hacer?', choices });
+    if (option === choices[0]) await this.adjustSensorSettings();
+    else if (option === choices[1]) await this.toggleHibernation();
+    else if (option === choices[2]) this.startMonitoring();
+    else if (option === choices[3]) process.exit();
+  }
+
+  async adjustSensorSettings() {
+    const sensorSettings = await enquirer.prompt([
+      { type: 'input', name: 'humidity', message: `Humedad ideal (actual: ${this.plantInfo.humidity.min}-${this.plantInfo.humidity.max}%):`, default: `${this.plantInfo.humidity.min}-${this.plantInfo.humidity.max}` },
+      { type: 'input', name: 'temperature', message: `Temperatura ideal (actual: ${this.plantInfo.temperature.min}-${this.plantInfo.temperature.max}°C):`, default: `${this.plantInfo.temperature.min}-${this.plantInfo.temperature.max}` },
+      { type: 'input', name: 'light', message: `Luz ideal (actual: ${this.plantInfo.lighting.min}-${this.plantInfo.lighting.max} lux):`, default: `${this.plantInfo.lighting.min}-${this.plantInfo.lighting.max}` },
+    ]);
+    this.plantInfo.humidity = this.parseRange(sensorSettings.humidity);
+    this.plantInfo.temperature = this.parseRange(sensorSettings.temperature);
+    this.plantInfo.lighting = this.parseRange(sensorSettings.light);
+    this.setupAlerts();
+    console.log(`Nuevos valores ajustados:\nHumedad: ${this.plantInfo.humidity.min}-${this.plantInfo.humidity.max}%\nTemperatura: ${this.plantInfo.temperature.min}-${this.plantInfo.temperature.max}°C\nLuz: ${this.plantInfo.lighting.min}-${this.plantInfo.lighting.max} lux`);
+  }
+
+  parseRange(rangeString) {
+    const [min, max] = rangeString.split('-').map(Number);
+    return { min, max };
+  }
+
+  async toggleHibernation() {
+    const { hibernation } = await enquirer.prompt({
+      type: 'confirm',
+      name: 'hibernation',
+      message: '¿Activar modo de hibernación?',
+      default: false,
+    });
+    this.hibernationMode = hibernation;
+    console.log(`Modo de hibernación ${this.hibernationMode ? 'activado' : 'desactivado'}.`);
+  }
+
+  checkAlerts() {
+    if (!this.hasSensors) return;
+    for (const [sensor, value] of Object.entries(this.sensors)) {
+      if (value === null || value === undefined || isNaN(value)) continue;
+      if (value < this.alerts[sensor].min) console.log(chalk.red(this.messages.alerts[sensor].low.replace('{value}', value.toFixed(2))));
+      else if (value > this.alerts[sensor].max) console.log(chalk.red(this.messages.alerts[sensor].high.replace('{value}', value.toFixed(2))));
+    }
+  }
+}
+
+const plant = new SmartPlant();
+plant.start().catch(err => console.error(chalk.red('❌ Error al iniciar:'), err.message));