refactor: simplificación y limpieza de código en la configuración de la aplicación

- Se simplificaron los scripts de lanzamiento y se mejoró la gestión de directorios de datos, eliminando complejidades innecesarias.
- Se actualizó `LoggerConfig` para utilizar rutas absolutas desde `AppDataDirectory`, asegurando una configuración de logging más robusta.
- Se corrigió la inicialización de directorios en `Main` para garantizar que existan antes de cargar el logger.
- Se mejoró la configuración de VS Code para establecer el directorio de trabajo correcto en `launch.json`.
- Se actualizó el changelog.md con un resumen de los cambios realizados y problemas resueltos.

Fixes: problemas de configuración y gestión de directorios en la aplicación.

Author: edu

.vscode/launch.json

@@ -8,6 +8,7 @@
             "mainClass": "com.example.forevernote.Main",
             "projectName": "forevernote",
             "preLaunchTask": "maven-exec-java",
+            "cwd": "${workspaceFolder}/Forevernote",
             "noDebug": true
         },
         {
@@ -17,6 +18,7 @@
             "mainClass": "com.example.forevernote.Main",
             "projectName": "forevernote",
             "preLaunchTask": "maven-compile",
+            "cwd": "${workspaceFolder}/Forevernote",
             "vmArgs": "-Dfile.encoding=UTF-8"
         }
     ]

Forevernote/src/main/java/com/example/forevernote/AppDataDirectory.java

@@ -0,0 +1,132 @@
+package com.example.forevernote;
+
+import java.io.File;
+
+/**
+ * Utility class to determine the application data directory.
+ * 
+ * Strategy:
+ * 1. First, try to use relative paths (data/, logs/) - works for development and portable apps
+ * 2. If that fails (read-only directory), use platform-specific user data directory
+ * 
+ * Standard directories by platform (fallback):
+ * - Windows: %APPDATA%\Forevernote
+ * - macOS:   ~/Library/Application Support/Forevernote
+ * - Linux:   ~/.config/Forevernote
+ */
+public class AppDataDirectory {
+    
+    private static final String APP_NAME = "Forevernote";
+    private static String baseDir = null;
+    
+    /**
+     * Gets the base directory for application data.
+     * First tries relative path, falls back to platform-specific directory.
+     */
+    public static String getBaseDirectory() {
+        if (baseDir != null) {
+            return baseDir;
+        }
+        
+        // Strategy 1: Try relative path (works for development and portable apps)
+        String userDir = System.getProperty("user.dir", ".");
+        File testDir = new File(userDir, "data");
+        
+        if (canWriteToDirectory(testDir)) {
+            baseDir = userDir;
+            return baseDir;
+        }
+        
+        // Strategy 2: Use platform-specific directory (for packaged apps in read-only locations)
+        baseDir = getPlatformAppDataDirectory();
+        return baseDir;
+    }
+    
+    /**
+     * Checks if we can write to a directory (exists and writable, or can be created).
+     */
+    private static boolean canWriteToDirectory(File dir) {
+        try {
+            if (dir.exists()) {
+                return dir.isDirectory() && dir.canWrite();
+            }
+            // Try to create and delete to test write permission
+            if (dir.mkdirs()) {
+                dir.delete();
+                return true;
+            }
+            return false;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+    
+    /**
+     * Gets the platform-specific application data directory.
+     */
+    private static String getPlatformAppDataDirectory() {
+        String osName = System.getProperty("os.name", "").toLowerCase();
+        String home = System.getProperty("user.home");
+        File appDataDir;
+        
+        if (osName.contains("win")) {
+            // Windows: %APPDATA%\Forevernote
+            String appData = System.getenv("APPDATA");
+            if (appData != null && !appData.isEmpty()) {
+                appDataDir = new File(appData, APP_NAME);
+            } else {
+                appDataDir = new File(home, "AppData\\Roaming\\" + APP_NAME);
+            }
+        } else if (osName.contains("mac")) {
+            // macOS: ~/Library/Application Support/Forevernote
+            appDataDir = new File(home, "Library/Application Support/" + APP_NAME);
+        } else {
+            // Linux: ~/.config/Forevernote (XDG Base Directory)
+            String xdgConfig = System.getenv("XDG_CONFIG_HOME");
+            if (xdgConfig != null && !xdgConfig.isEmpty()) {
+                appDataDir = new File(xdgConfig, APP_NAME);
+            } else {
+                appDataDir = new File(home, ".config/" + APP_NAME);
+            }
+        }
+        
+        return appDataDir.getAbsolutePath();
+    }
+    
+    /**
+     * Gets the data directory path (baseDir/data).
+     */
+    public static String getDataDirectory() {
+        return new File(getBaseDirectory(), "data").getAbsolutePath();
+    }
+    
+    /**
+     * Gets the logs directory path (baseDir/logs).
+     */
+    public static String getLogsDirectory() {
+        return new File(getBaseDirectory(), "logs").getAbsolutePath();
+    }
+    
+    /**
+     * Ensures data and logs directories exist.
+     * Called by Main at startup before logger initialization.
+     */
+    public static boolean ensureDirectoriesExist() {
+        try {
+            File dataDir = new File(getDataDirectory());
+            File logsDir = new File(getLogsDirectory());
+            
+            if (!dataDir.exists()) {
+                dataDir.mkdirs();
+            }
+            if (!logsDir.exists()) {
+                logsDir.mkdirs();
+            }
+            
+            return dataDir.exists() && dataDir.canWrite() && 
+                   logsDir.exists() && logsDir.canWrite();
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}

Forevernote/src/main/java/com/example/forevernote/Main.java

@@ -1,6 +1,7 @@
 package com.example.forevernote;
 
 import javafx.application.Application;
+import javafx.application.Platform;
 import javafx.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
@@ -9,32 +10,19 @@
 import com.example.forevernote.config.LoggerConfig;
 import com.example.forevernote.data.SQLiteDB;
 
+import java.io.File;
 import java.io.IOException;
 import java.util.logging.Logger;
 
 /**
  * Main application class for Forevernote.
- * This class initializes the JavaFX application and sets up the primary stage.
  */
 public class Main extends Application {
 
-    // Static block to ensure directories exist before logger initialization
+    // Create directories BEFORE logger loads (logger needs logs/ to exist)
     static {
-        // Create data and logs directories before LoggerConfig initializes FileHandler
-        // This must happen before any logger is created
-        try {
-            java.io.File dataDir = new java.io.File("data");
-            if (!dataDir.exists()) {
-                dataDir.mkdirs();
-            }
-            
-            java.io.File logsDir = new java.io.File("logs");
-            if (!logsDir.exists()) {
-                logsDir.mkdirs();
-            }
-        } catch (Exception e) {
-            // If directory creation fails, log to console since logger may not be ready
-            System.err.println("Warning: Could not create data/logs directories: " + e.getMessage());
+        if (!AppDataDirectory.ensureDirectoriesExist()) {
+            System.err.println("Warning: Could not create data/logs directories");
         }
     }
 
@@ -43,80 +31,67 @@ public class Main extends Application {
     @Override
     public void start(Stage primaryStage) {
         try {
-            // Initialize database
             initializeDatabase();
 
-            // Load main view
-            FXMLLoader loader = new FXMLLoader(getClass().getResource("/com/example/forevernote/ui/view/MainView.fxml"));
+            FXMLLoader loader = new FXMLLoader(getClass().getResource(
+                "/com/example/forevernote/ui/view/MainView.fxml"));
             Scene scene = new Scene(loader.load(), 1200, 800);
 
-            // Apply CSS styling
-            var cssResource = getClass().getResource("/com/example/forevernote/ui/css/modern-theme.css");
+            var cssResource = getClass().getResource(
+                "/com/example/forevernote/ui/css/modern-theme.css");
             if (cssResource != null) {
                 scene.getStylesheets().add(cssResource.toExternalForm());
-            } else {
-                logger.warning("Could not load CSS stylesheet: modern-theme.css not found");
             }
 
-            // Configure primary stage
             primaryStage.setTitle("Forevernote - Free Note Taking");
 
-            // Try to load app icon (optional)
             try {
-                var iconStream = getClass().getResourceAsStream("/com/example/forevernote/ui/images/app-icon.png");
+                var iconStream = getClass().getResourceAsStream(
+                    "/com/example/forevernote/ui/images/app-icon.png");
                 if (iconStream != null) {
                     primaryStage.getIcons().add(new Image(iconStream));
                 }
             } catch (Exception e) {
-                logger.warning("Could not load app icon: " + e.getMessage());
+                // Icon is optional
             }
 
             primaryStage.setScene(scene);
             primaryStage.setMinWidth(800);
             primaryStage.setMinHeight(600);
-            
-            // Show the stage
             primaryStage.show();
 
-            logger.info("Forevernote application started successfully");
+            // macOS focus workaround
+            if (System.getProperty("os.name", "").toLowerCase().contains("mac")) {
+                Platform.runLater(() -> {
+                    primaryStage.toFront();
+                    primaryStage.requestFocus();
+                });
+            }
+            
+            logger.info("Forevernote started. Data: " + AppDataDirectory.getDataDirectory());
 
         } catch (IOException e) {
             logger.severe("Failed to load main view: " + e.getMessage());
             throw new RuntimeException("Failed to start application", e);
         }
     }
 
-    /**
-     * Initializes the SQLite database.
-     * Uses data/database.db relative to the working directory.
-     * Scripts ensure execution from Forevernote/ directory.
-     * Note: data/ and logs/ directories are already created in the static block.
-     */
     private void initializeDatabase() {
         try {
-            // Directories are already created in static block, but ensure they exist as a safety check
-            java.io.File dataDir = new java.io.File("data");
-            if (!dataDir.exists()) {
-                dataDir.mkdirs();
-                logger.warning("Data directory was missing and recreated");
-            }
+            String dbPath = new File(AppDataDirectory.getDataDirectory(), "database.db")
+                .getAbsolutePath();
+            
+            SQLiteDB.configure(dbPath);
+            SQLiteDB.getInstance().initDatabase();
 
-            SQLiteDB.configure("data/database.db");
-            SQLiteDB db = SQLiteDB.getInstance();
-            db.initDatabase();
-            logger.info("Database initialized successfully");
+            logger.info("Database initialized at: " + dbPath);
         } catch (Exception e) {
             logger.severe("Failed to initialize database: " + e.getMessage());
             throw new RuntimeException("Database initialization failed", e);
         }
     }
 
-    /**
-     * Main method to launch the application.
-     * 
-     * @param args Command line arguments
-     */
     public static void main(String[] args) {
         launch(args);
     }
-}
+}

Forevernote/src/main/java/com/example/forevernote/config/LoggerConfig.java

@@ -1,39 +1,81 @@
 package com.example.forevernote.config;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.FileHandler;
+import java.util.logging.Level;
 import java.util.logging.LogManager;
 import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+
+import com.example.forevernote.AppDataDirectory;
 
 /**
- * LoggerConfig is responsible for configuring the logging system for the application.
- * It reads the logging configuration from a properties file and sets up the logging system accordingly.
+ * Configures the logging system for the application.
+ * 
+ * Reads base configuration from logging.properties, then configures
+ * the FileHandler to use the correct logs directory from AppDataDirectory.
+ * 
+ * Note: AppDataDirectory.ensureDirectoriesExist() must be called before
+ * this class is loaded (done in Main's static block).
  */
 public class LoggerConfig {
 
-	// Static block to configure the logger
     static {
-    	// Crear una carpeta resource e incluirla en el classpath para que getResourceAsStream lo encuentre
-    	// Attempt to load the logging configuration from the 'logging.properties' file
-        try (InputStream configFile = LoggerConfig.class.getClassLoader().getResourceAsStream("logging.properties")) {
+        try (InputStream configFile = LoggerConfig.class.getClassLoader()
+                .getResourceAsStream("logging.properties")) {
+            
             if (configFile == null) {
-            	// Throw an exception if the configuration file is not found
                 throw new IOException("Could not find logging.properties file");
             }
-        	// Load the logging configuration from the properties file
+            
+            // Load base configuration
             LogManager.getLogManager().readConfiguration(configFile);
-
+            
+            // Configure FileHandler with absolute path from AppDataDirectory
+            configureFileHandler();
+            
         } catch (IOException e) {
-        	// Log a severe error if there is an issue loading the configuration file
-            Logger.getLogger(LoggerConfig.class.getName()).severe("Could not load logging configuration: " + e.getMessage());
+            Logger.getLogger(LoggerConfig.class.getName())
+                .severe("Could not load logging configuration: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * Configures the FileHandler with the correct absolute path.
+     */
+    private static void configureFileHandler() {
+        try {
+            String logsDir = AppDataDirectory.getLogsDirectory();
+            String logFile = new File(logsDir, "app.log").getAbsolutePath();
+            
+            // Reset and reconfigure with absolute path
+            LogManager.getLogManager().reset();
+            
+            // Console handler
+            ConsoleHandler consoleHandler = new ConsoleHandler();
+            consoleHandler.setLevel(Level.INFO);
+            consoleHandler.setFormatter(new SimpleFormatter());
+            Logger.getLogger("").addHandler(consoleHandler);
+            
+            // File handler with absolute path
+            FileHandler fileHandler = new FileHandler(logFile, true);
+            fileHandler.setLevel(Level.ALL);
+            fileHandler.setFormatter(new SimpleFormatter());
+            Logger.getLogger("").addHandler(fileHandler);
+            
+            // Root logger level
+            Logger.getLogger("").setLevel(Level.ALL);
+            
+        } catch (Exception e) {
+            System.err.println("Warning: Could not configure file logging: " + e.getMessage());
         }
     }
 
     /**
      * Returns the logger for the given class.
-     * 
-     * @param clazz the class for which to get the logger
-     * @return the logger instance
      */
     public static Logger getLogger(Class<?> clazz) {
         return Logger.getLogger(clazz.getName());