smartplant 0.1.4 → 0.1.6

package/README.md

@@ -1,17 +1,28 @@
 
-# SmartPlant
+# SmartPlant by *PIGEONPOSSE*
 
 [![HEADER](https://github.com/pigeonposse/.github/blob/main/docs/banner-smartplant.png?raw=true)](https://github.com/pigeonposse)
 
 
-**SmartPlant** is a pioneering library designed for plant care with AI technology, aimed at integrating automated alerts with multi-language support. This standard prototype library is crafted for intelligent devices that manage plant care, enhancing the level of interaction and intelligence between plants and their owners. The core idea behind SmartPlant is to pave the way for advancements in plant care technology. It serves as a foundation for developing more sophisticated solutions and experimenting with innovative devices that cater to the needs of plants. By leveraging this library, developers can contribute to evolving the ecosystem of smart plant care.
+**SmartPlant** is a library designed to simplify plant care through *the integration of advanced artificial intelligence models*. This technology not only researches detailed information about each type of plant but also determines the optimal conditions for their care, thereby maximizing their growth and health. Thanks to this functionality, users can efficiently monitor and manage the environment of their plants *using sensors that measure humidity, light, and temperature*.
+
+The core idea behind SmartPlant is to *pave the way for advancements in plant care technology*. It serves as a foundation for developing more sophisticated solutions and experimenting with innovative devices that meet the needs of plants. By leveraging this library, developers can contribute to the evolution of the smart plant care ecosystem.
+
+> [!WARNING]
+> Currently in phase `Beta`
+
+## AI and the future intertwine: connect with your environment.
 
 ## Features
 
-*   Multi-language support
-*   Alerts for plant care (moisture, sunlight, water, soil, temperature)
-*   Local and external input methods
-*   Automatic configuration and notifications
+- 🤖 **Integrated Artificial Intelligence:** Optimizes the care of each plant.
+- 📊 **Real-Time Monitoring:** Collects humidity, light, and temperature with sensors.
+- 🔔 **Customized Alerts:** Notifications for out-of-range conditions.
+- 💬 **Multilingual Support:** English, Español, Français, Deutsch, Italiano, Português, Nederlands, Русский, 中文, 日本語.
+- 🎛 **Easy Setup:** Intuitive process for Raspberry Pi or Arduino.
+- 📈 **Data History:** Environmental trend analysis.
+- 🔮 **Critical Condition Prediction:** Prevents significant changes in plant health.
+- 🌍 **Open-source:** MIT licensed, available for public use and contributions.
 
 ## Installation
 
@@ -21,98 +32,77 @@ To install the library, use npm:
 npm install smartplant
 ```
 
-## Usage
-
-To start using SmartPlant, follow these steps:
-
-1.  **Import the Library**
-    
-    ```
-    import SmartPlant  from 'smartplant'
-    ```
-    
-2.  **Create an Instance and Configure**
-    
-    ```
-    
-    const smartPlant = new SmartPlant();
-    
-    // Select language
-    smartPlant.setLanguage('en'); // Options: 'en', 'es', 'fr', 'de', 'it', 'pt', 'nl', 'ru', 'zh', 'ja'
-    
-    // Select input method
-    smartPlant.setInputMethod('local'); // Options: 'local', 'extern'
-                
-    ```
-    
-3.  **Configure the Plant**
-    
-    ```
-    
-    smartPlant.setPlantType('indoor'); // Options: 'indoor', 'outdoor'
-    smartPlant.setPlantName('Ficus'); // Replace 'Ficus' with the name of your plant
-    
-    // Configure alerts
-    smartPlant.configureAlerts();
-                
-    ```
-    
-4.  **Start Monitoring**
-    
-    ```
-    smartPlant.startMonitoring();
-    ```
-    
-
-## Language Configuration
-
-You can configure the language as follows:
+# Benefits of the emojis system
 
-```
-smartPlant.setLanguage('en'); // Change 'en' to the desired language code
-```
+This approach with emojis provides a simplified and visually attractive user experience.It allows even those without deep technical knowledge to quickly understand the state of the plant and take the necessary measures.It is a way to offer immediate and clear feedback, improving interaction with the system and promoting more regular and careful maintenance of the plant.
+
+## Emojis scales for parameter monitoring
+
+To make the plant monitoring more intuitive and visually accessible, we have implemented an emojis system that represents different levels of each critical parameter: moisture, light and temperature.Each emoji offers a rapid representation of the current status of the parameter, which facilitates interpretation without analyzing specific numbers.
+
+#### Humidity:
+- 🍂 **Very dry:** Indicates that moisture is below the recommended minimum range.The plant is at risk of dehydration.
+- 🌿 **Ideal:** Moisture is within the ideal range, which means that the plant is in optimal conditions.
+- 💧 **Slightly wet:** Indicates that moisture is slightly above the ideal range, but it is not yet worrisome.
+- 🌊 **Very humid:** Moisture is above the maximum allowed range, which could lead to saturation and problems such as waterlogging.
+
+#### Light:
+- 🌑 **Very little light:** points out that the plant receives less light than necessary, which could affect its growth.
+- 🌥 **Ideal:** The plant receives the amount of light adequate for healthy development.
+- 🌞 **Too much light:** Light exposure is excessive, which can cause burns or stress in the plant.
+
+#### Temperature:
+- 🧊 **Very cold:** The temperature is below the minimum range, which can slow down or damage the plant.
+- 🌡️ **Ideal:** The temperature is in the optimal range for the growth and development of the plant.
+- 🔥 **Very hot:** The temperature exceeds the maximum range, which could cause overheating and dehydration.
 
-Available languages are:
+### Emojis-based happiness system
 
-*   en - English
-*   es - Spanish
-*   fr - French
-*   de - German
-*   it - Italian
-*   pt - Portuguese
-*   nl - Dutch
-*   ru - Russian
-*   zh - Chinese
-*   ja - Japanese
+In addition to the specific parameters, we have designed a system of general happiness for the plant, which is represented with caritas emojis.This system provides a global vision of the state of the plant, based on a combination of its levels of humidity, light and temperature.
 
-## Input Methods
+#### Happiness scale:
+- 🤩 **Very happy:** The plant is in ideal conditions in all key parameters.This is the optimal state.
+- 😊 **Happy:** The plant is in good condition, although there could be slight deviations in some parameters.
+- 😐 **Acceptable:** The plant is in acceptable conditions, but is far from ideal.Small adjustments may be required.
+- 😞 **Bad conditions:** The plant is experiencing unfavorable conditions and needs attention to avoid major damage.
+- 😖 **Critical conditions:** The plant is in a critical state and requires immediate action to prevent its condition will get worse.
+- 🥵 **Extremely critical:** The plant is in an extremely critical state and is in danger of dying if urgent measures are not taken.
+- 😵 **No Data Detected:** Vital signals missing or sensors not transmitting requiring immediate check.
+  
+## ☕ Donate
 
-Choose between:
+Help us to develop more interesting things.
 
-*   **Local**: Detects plants on your computer.
-*   **External**: Uses an external API; requires an API key.
+[![Donate](https://img.shields.io/badge/Donate-grey?style=for-the-badge)](https://pigeonposse.com/?popup=donate)
 
-## Alert Messages
+## 📜 License
 
-\*\*SmartPlant\*\* provides customized messages based on the plant's needs. Here are some examples:
+This software is licensed with **[GPL-3.0](/LICENSE)**.
 
-*   **Low Moisture**: "The moisture in my soil is low. I need water!"
-*   **Low Sunlight**: "I am receiving too little sunlight. I need more sun!"
-*   **High Temperature**: "The temperature is too high. Please lower it!"
-*   **Happy**: "I am very happy and healthy!"
+[![Read more](https://img.shields.io/badge/Read-more-grey?style=for-the-badge)](/LICENSE)
 
-## Contributions
+## 🐦 About us
 
-Contributions are welcome. If you wish to contribute, please review the \[CONTRIBUTING.md\](CONTRIBUTING.md) file for more details.
+*PigeonPosse* is a ✨ **code development collective** ✨ focused on creating practical and interesting tools that help developers and users enjoy a more agile and comfortable experience. Our projects cover various programming sectors and we do not have a thematic limitation in terms of projects.
 
-## License
+[![More](https://img.shields.io/badge/Read-more-grey?style=for-the-badge)](https://github.com/pigeonposse)
 
-This project is licensed under the MIT License - see the \[LICENSE\](LICENSE) file for details.
+### Collaborators
 
-## Contact
+|                                                                                    | Name        | Role         | GitHub                                         |
+| ---------------------------------------------------------------------------------- | ----------- | ------------ | ---------------------------------------------- |
+| <img src="https://github.com/alejomalia.png?size=72" alt="Angelo" style="border-radius:100%"/> | Alejo |   Author & Development   | [@alejomalia](https://github.com/alejomalia) |
+| <img src="https://github.com/PigeonPosse.png?size=72" alt="PigeonPosse" style="border-radius:100%"/> | PigeonPosse | Collective | [@PigeonPosse](https://github.com/PigeonPosse) |
 
-For questions or support, contact \[your-email@example.com\](mailto:your-email@example.com).
+<br>
+<p align="center">
 
-- - -
+[![Web](https://img.shields.io/badge/Web-grey?style=for-the-badge&logoColor=white)](https://pigeonposse.com)
+[![About Us](https://img.shields.io/badge/About%20Us-grey?style=for-the-badge&logoColor=white)](https://pigeonposse.com?popup=about)
+[![Donate](https://img.shields.io/badge/Donate-pink?style=for-the-badge&logoColor=white)](https://pigeonposse.com/?popup=donate)
+[![Github](https://img.shields.io/badge/Github-black?style=for-the-badge&logo=github&logoColor=white)](https://github.com/pigeonposse)
+[![Twitter](https://img.shields.io/badge/Twitter-black?style=for-the-badge&logo=twitter&logoColor=white)](https://twitter.com/pigeonposse_)
+[![Instagram](https://img.shields.io/badge/Instagram-black?style=for-the-badge&logo=instagram&logoColor=white)](https://www.instagram.com/pigeon.posse/)
+[![Medium](https://img.shields.io/badge/Medium-black?style=for-the-badge&logo=medium&logoColor=white)](https://medium.com/@pigeonposse)
 
-Thank you for using **SmartPlant**. We hope you enjoy managing your plants with our library.
+</p>

package/main.js

@@ -0,0 +1,606 @@
+import { execSync } from 'child_process';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs';
+import { SerialPort } from 'serialport';
+import { ReadlineParser } from '@serialport/parser-readline';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import axios from 'axios';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function loadMessages(language) {
+    const languageFile = path.join(__dirname, `language/messages-${language}.json`);
+    try {
+        return JSON.parse(fs.readFileSync(languageFile, 'utf8'));
+    } catch (error) {
+        console.error(`Error loading language file: ${error.message}`);
+        return JSON.parse(fs.readFileSync(path.join(__dirname, 'language/messages-en.json'), 'utf8'));
+    }
+}
+
+class AIClient {
+    constructor(type, apiKey, localModel) {
+        this.type = type;
+        this.apiKey = apiKey;
+        this.localModel = localModel;
+    }
+
+    async generateResponse(prompt, language) {
+        const languagePrompt = `Respond in ${language}. `;
+        const fullPrompt = languagePrompt + prompt;
+        
+        switch (this.type) {
+            case 'openai':
+                return this.generateOpenAIResponse(fullPrompt);
+            case 'local':
+                return this.generateLocalResponse(fullPrompt);
+            default:
+                throw new Error('Unsupported AI type');
+        }
+    }
+
+    async generateOpenAIResponse(prompt) {
+        try {
+            const response = await axios.post('https://api.openai.com/v1/engines/davinci-codex/completions', {
+                prompt: prompt,
+                max_tokens: 500,
+                n: 1,
+                stop: null,
+                temperature: 0.7,
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            return response.data.choices[0].text.trim();
+        } catch (error) {
+            console.error('Error generating OpenAI response:', error);
+            return null;
+        }
+    }
+
+    async generateLocalResponse(prompt) {
+        try {
+            const command = `ollama run ${this.localModel} "${this.sanitizeInput(prompt)}"`;
+            const output = execSync(command, { encoding: 'utf-8' });
+            return output.trim();
+        } catch (error) {
+            console.error('Error generating local response:', error);
+            return null;
+        }
+    }
+
+    sanitizeInput(input) {
+        return input.replace(/"/g, '\\"').replace(/\n/g, ' ');
+    }
+}
+
+class AIDetector {
+    async detectAI() {
+        try {
+            const output = execSync('ollama list', { encoding: 'utf-8' });
+            const models = output.split('\n')
+                .filter(line => line.trim() && !line.startsWith('NAME'))
+                .map(line => line.split(' ')[0]);
+            if (models.length > 0) {
+                return {
+                    name: 'ollama',
+                    models: models
+                };
+            }
+        } catch (error) {
+            console.error('Error detecting Ollama:', error.message);
+        }
+        return null;
+    }
+}
+
+class PlantDates {
+    constructor(name, type, aiClient, language) {
+        this.name = name;
+        this.type = type;
+        this.aiClient = aiClient;
+        this.language = language;
+        this.plantInfo = null;
+    }
+
+    async generateInfo() {
+        console.log(chalk.bold('🔍🌿 Generating plant information...'));
+        
+        try {
+            const plantInfoPrompt = `Provide a comprehensive summary for ${this.name} (${this.type}) including: Lighting, Watering, Temperature, Humidity, Soil, Fertilization, Pruning, and Propagation. Also, provide specific ranges for Lighting (in lux), Temperature (in Celsius), and Humidity (in percentage) in the format: "Lighting: X-Y lux, Temperature: A-B°C, Humidity: C-D%".`;
+            
+            const plantInfoResponse = await this.getAIResponse(plantInfoPrompt);
+            
+            // Extract ranges from the response
+            const lightingMatch = plantInfoResponse.match(/Lighting:\s*(\d+)-(\d+)\s*lux/i);
+            const temperatureMatch = plantInfoResponse.match(/Temperature:\s*(\d+)-(\d+)\s*°C/i);
+            const humidityMatch = plantInfoResponse.match(/Humidity:\s*(\d+)-(\d+)\s*%/i);
+
+            this.plantInfo = {
+                summary: plantInfoResponse,
+                lighting: lightingMatch ? { min: parseInt(lightingMatch[1]), max: parseInt(lightingMatch[2]) } : { min: 50, max: 700 },
+                temperature: temperatureMatch ? { min: parseInt(temperatureMatch[1]), max: parseInt(temperatureMatch[2]) } : { min: 18, max: 24 },
+                humidity: humidityMatch ? { min: parseInt(humidityMatch[1]), max: parseInt(humidityMatch[2]) } : { min: 40, max: 60 }
+            };
+
+            return this.plantInfo;
+        } catch (error) {
+            console.error('Error generating plant info:', error);
+            return null;
+        }
+    }
+
+    async getAIResponse(prompt) {
+        try {
+            const response = await this.aiClient.generateResponse(prompt, this.language);
+            await this.simulateTyping(response);
+            return response.trim();
+        } catch (error) {
+            console.error('Error getting AI response:', error);
+            return null;
+        }
+    }
+
+    async simulateTyping(text) {
+        for (let i = 0; i < text.length; i++) {
+            process.stdout.write(text[i]);
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        console.log('\n');
+    }
+
+    formatPlantInfo() {
+        if (!this.plantInfo) return 'No hay información disponible.';
+
+        return `
+Rangos ideales:
+🌞 ${this.plantInfo.lighting.min}-${this.plantInfo.lighting.max} lux
+🌡️ ${this.plantInfo.temperature.min}-${this.plantInfo.temperature.max}°C
+💦 ${this.plantInfo.humidity.min}-${this.plantInfo.humidity.max}%
+        `;
+    }
+}
+
+class SmartPlant {
+    constructor() {
+        this.plantType = null;
+        this.plantName = '';
+        this.alerts = {};
+        this.language = 'en';
+        this.messages = null;
+        this.sensors = {
+            humidity: null,
+            light: null,
+            temperature: null
+        };
+        this.plantInfo = null;
+        this.platform = null;
+        this.serialPort = null;
+        this.aiClient = null;
+        this.aiDetector = new AIDetector();
+        this.historicalData = [];
+        this.isMonitoring = false;
+        this.hibernationMode = false;
+        this.hasSensors = false;
+    }
+
+    async init() {
+        this.messages = loadMessages(this.language);
+    }
+
+    async setLanguage(language) {
+        this.language = language;
+        this.messages = loadMessages(this.language);
+    }
+
+    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(); // Add a space after AI connection
+        await this.selectPlantType();
+        await this.setPlantName();
+        await this.generatePlantInfo();
+        await this.setupSensors();
+        this.setupAlerts();
+        this.startMonitoring();
+    }
+
+    async selectLanguage() {
+        const { language } = await inquirer.prompt({
+            type: 'list',
+            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 inquirer.prompt({
+            type: 'list',
+            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 });
+            const parser = this.serialPort.pipe(new ReadlineParser({ delimiter: '\r\n' }));
+            parser.on('data', this.handleArduinoData.bind(this));
+            console.log('Arduino setup complete. Make sure arduino_dht22.ino is uploaded to your Arduino.');
+            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 { method } = await inquirer.prompt({
+            type: 'list',
+            name: 'method',
+            message: 'Select AI method:',
+            choices: [
+                { name: 'Local (Ollama)', value: 'local' },
+                { name: 'OpenAI API', value: 'openai' }
+            ]
+        });
+
+        if (method === 'local') {
+            await this.selectLocalModel();
+        } else {
+            const { apiKey } = await inquirer.prompt({
+                type: 'input',
+                name: 'apiKey',
+                message: 'Enter your API key:'
+            });
+            this.aiClient = new AIClient(method, apiKey);
+        }
+        console.log(chalk.green('AI successfully connected! 🤖✨'));
+    }
+
+    async selectLocalModel() {
+        const aiModels = await this.aiDetector.detectAI();
+        if (aiModels && aiModels.models.length > 0) {
+            const { model } = await inquirer.prompt({
+                type: 'list',
+                name: 'model',
+                message: 'Select a local model:',
+                choices: aiModels.models
+            });
+            this.aiClient = new AIClient('local', null, model);
+        } else {
+            console.log('No local AI models found.');
+        }
+    }
+
+    async selectPlantType() {
+        const { type } = await inquirer.prompt({
+            type: 'list',
+            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 inquirer.prompt({
+            type: 'input',
+            name: 'name',
+            message: this.messages.general.enterPlantName
+        });
+        this.plantName = name;
+    }
+
+    async generatePlantInfo() {
+        const plantDates = new PlantDates(this.plantName, this.plantType, this.aiClient, this.language);
+        this.plantInfo = await plantDates.generateInfo();
+        if (this.plantInfo) {
+            this.idealRanges = plantDates.formatPlantInfo();
+        } else {
+            console.log('No se pudo generar la información de la planta.');
+        }
+    }
+
+    async setupSensors() {
+        console.log(chalk.bold(this.messages.general.settingUpSensors));
+        if (this.hasSensors) {
+            if (this.platform === 'raspberry') {
+                // For Raspberry Pi, we'll wait for actual sensor data
+                console.log('Waiting for sensor data from Raspberry Pi...');
+            }
+            // For Arduino, we're already set up in setupPlatform
+        } else {
+            console.log(chalk.yellow('No sensors detected. Running in simulation mode.'));
+        }
+        console.log(chalk.bold(this.messages.general.sensorsReady));
+    }
+
+    setupAlerts() {
+        if (this.plantInfo) {
+            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 }
+            };
+            console.log(this.messages.general.alertsSet);
+        } else {
+            console.log('No se pudieron configurar las alertas debido a la falta de información de la planta.');
+        }
+    }
+
+    calculatePercentage(value, min, max) {
+        if (value === null || value === undefined || isNaN(value)) {
+            return 0;
+        }
+        return Math.min(Math.max(((value - min) / (max - min)) * 100, 0), 100);
+    }
+
+    getHumidityEmoji(percentage) {
+        if (percentage <= 0) return "🍂";
+        if (percentage <= 30) return "🍂";
+        if (percentage <= 60) return "🌿";
+        if (percentage <= 80) return "💧";
+        return "🌊";
+    }
+
+    getLightEmoji(percentage) {
+        if (percentage <= 0) return "🌑";
+        if (percentage <= 30) return "🌑";
+        if (percentage <= 60) return "🌥";
+        return "🌞";
+    }
+
+    getTemperatureEmoji(percentage) {
+        if (percentage <= 0) return "🧊";
+        if (percentage <= 30) return "🧊";
+        if (percentage <= 80) return "🌡️";
+        return "🔥";
+    }
+
+    getHappinessEmoji(averagePercentage) {
+        if (averagePercentage <= 0) return '😵';
+        if (averagePercentage >= 90) return '🤩';
+        if (averagePercentage >= 75) return '😊';
+        if (averagePercentage >= 60) return '😐';
+        if (averagePercentage >= 45) return '😞';
+        if (averagePercentage >= 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; // Need more data for prediction
+
+        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) { // Significant trend detected
+                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;
+
+        const slope = (n * sum_xy - sum_x * sum_y) / (n * sum_xx - sum_x * sum_x);
+        return slope;
+    }
+
+    startMonitoring() {
+        console.log(this.messages.general.startMonitoring);
+        this.isMonitoring = true;
+        this.monitoringInterval = setInterval(() => {
+            if (!this.hibernationMode) {
+                this.logPlantStatus();
+            }
+        }, 60000); // Log every minute
+
+        // Enable keypress detection
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (key) => {
+            if (key === '\u0003') { // Ctrl+C
+                process.exit();
+            } else if (key === '\u000F') { // Ctrl+O
+                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 inquirer.prompt({
+            type: 'list',
+            name: 'option',
+            message: 'Monitoreo detenido. ¿Qué deseas hacer?',
+            choices: choices,
+        });
+
+        switch (option) {
+            case choices[0]:
+                await this.adjustSensorSettings();
+                break;
+            case choices[1]:
+                await this.toggleHibernation();
+                break;
+            case choices[2]:
+                this.startMonitoring();
+                break;
+            case choices[3]:
+                console.log('Saliendo del menú de ajustes.');
+                process.exit();
+        }
+    }
+
+    async adjustSensorSettings() {
+        const sensorSettings = await inquirer.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:
+Humedad: ${this.plantInfo.humidity.min}-${this.plantInfo.humidity.max}%
+Temperatura: ${this.plantInfo.temperature.min}-${this.plantInfo.temperature.max}°C
+Luz: ${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 inquirer.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 smartPlant = new SmartPlant();
+smartPlant.start().catch(console.error);
+
+export default SmartPlant;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "smartplant",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A library for managing plant care with alerts and multi-language support.",
-  "main": "comingsoon.js",
+  "main": "main.js",
   "type": "module",
   "dependencies": {
     "@serialport/parser-readline": "^12.0.0",
@@ -110,7 +110,7 @@
     ]
   },
   "scripts": {
-    "start": "node index.js",
+    "start": "node main.js",
     "update-version": "changeset && changeset version",
     "push": "git add . && cz && git push -f origin $@",
     "push:main": "pnpm push main"

package/comingsoon.js

@@ -1,6 +0,0 @@
-console.log(`COMING SOON!!
-View development progress at https://github.com/pigeonposse/smartplant
-
-Funding: https://github.com/sponsors/pigeonposse
-Repo: https://github.com/pigeonposse/smartplant    
-`)