Update PKGBUILD

Improved description and about as well as information for updating cflash

.SRCINFO

@@ -0,0 +1,15 @@
+pkgbase = cflash
+	pkgdesc = A small and lightweight wrapper for dd that strips away the complexity of CLI flashing.
+	pkgver = 1.0.1
+	pkgrel = 1
+	url = https://github.com/cametendo/cflash-git
+	arch = any
+	license = MIT
+	makedepends = java-environment>=21
+	makedepends = maven
+	makedepends = git
+	depends = java-runtime>=21
+	source = cflash::git+https://github.com/cametendo/cflash-git.git
+	sha256sums = SKIP
+
+pkgname = cflash

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+## Contributing
+
+Contributions from the community are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes with proper testing.
+4. Submit a pull request detailing your modifications.
+
+### Developer Documentation
+
+Developer documentation is generated using JavaDoc. To generate and view the documentation:
+
+```bash
+chmod +x generate_javadoc.sh
+./generate_javadoc.sh
+```
+
+This will create a `docs/` folder with HTML documentation you can view in your browser.

PKGBUILD

@@ -1,13 +1,13 @@
 # Maintainer: Cametendo cameronmathis08@gmail.com
 pkgname=cflash
-pkgver=1.0.0
+pkgver=1.0.1
 pkgrel=1
-pkgdesc="Small and lightweight image and iso flasher build on dd."
+pkgdesc="A small and lightweight wrapper for dd that strips away the complexity of CLI flashing."
 arch=('any')
 url="https://github.com/cametendo/cflash-git"
 license=('MIT') 
 depends=('java-runtime>=21')
-makedepends=('java-environment>=21' 'maven')
+makedepends=('java-environment>=21' 'maven' 'git')
 source=("cflash::git+https://github.com/cametendo/cflash-git.git")
 sha256sums=('SKIP')
 
@@ -20,9 +20,8 @@ build() {
 package() {
   cd "$srcdir/cflash"
   
-  # for some reason MAKEPKD won't accept my version, using the wildcard for literally anything if may find
-  install -Dm644 target/cflash-*-jar-with-dependencies.jar \
-    "$pkgdir/usr/share/java/cflash/cflash.jar"
+	install -Dm644 "target/${pkgname}-${pkgver}-jar-with-dependencies.jar" \
+	"$pkgdir/usr/share/java/${pkgname}/${pkgname}.jar"
 
   # Create the executable
   install -d "$pkgdir/usr/bin"

README.md

@@ -1,15 +1,13 @@
 # cflash
-Small and lightweight image and iso flasher build on `dd`. 
+A small and lightweight wrapper for `dd` that strips away the complexity of CLI flashing.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Java Version](https://img.shields.io/badge/Java-21%2B-orange.svg)](https://www.java.com/en/)
 [![Platform](https://img.shields.io/badge/Platform-Linux-brightgreen.svg)](https://www.linux.org/)
-[![Status](https://img.shields.io/badge/Status-Beta-red.svg)](https://en.wikipedia.org/wiki/Software_release_life_cycle#Beta)
+[![Version](https://img.shields.io/badge/version-1.0.0-blue)](https://github.com/Cametendo/cflash-git/releases/tag/cflash-1.0.0)
 
 # About
-Java program using `dd` to make flashing iso and image files easier on the terminal. This program allows anyone to flash iso and image files without having to search for extra GUI tools by keeping it simple and resource-friendly.
-
-## Getting Started
+Small and lightweight wrapper written in Java for `dd` designed to simplify CLI flashing while protecting your hardware from accidental command-line errors. cflash replaces the syntax with a clear, safe interface, providing a reliable workflow for both newcomers and power users.
 
 # Requirements
 - `Java`: 21 (Download [here](https://www.oracle.com/java/technologies/downloads/#java21))
@@ -32,12 +30,19 @@ Java program using `dd` to make flashing iso and image files easier on the termi
    mvn clean package
    ```
 
-3. Run the application:
+3. Run cflash:
 
    ```bash
    java -jar target/cflash-<version>.jar (optionally add arguments here, like with dd)
    ```
 
+4. Update cflash:
+
+   ```bash
+   git pull
+   mvn clean package
+   ```
+
 ### System-wide Installation
 
 To install cflash globally so that it can be run from any terminal:
@@ -55,10 +60,10 @@ To install cflash globally so that it can be run from any terminal:
    chmod +x build.sh install.sh
    ```
 
-3. Build the project using the provided build script:
+3. Build the project using the provided build script (requires root privileges):
 
    ```bash
-   ./build.sh
+   sudo ./build.sh
    ```
 
 4. Install globally (requires root privileges):
@@ -73,6 +78,12 @@ To install cflash globally so that it can be run from any terminal:
    cflash
    ```
 
+6. Update cflash (reguires root privileges):
+
+   ```bash
+   sudo cflash --update
+   ```
+
 **Notes:**
 
 * The `build.sh` script compiles all Java source files and creates an executable `cflash.jar`.
@@ -85,6 +96,12 @@ To install cflash globally so that it can be run from any terminal:
       cd cflash
       makepkg -si
       ```
+   * You can update cflash using `yay` / `paru` via `yay -S cflash` / `paru -S cflash` or by rebuilding the package:
+      ```bash
+      git clone https://aur.archlinux.org/cflash.git
+      cd cflash
+      makepkg -si
+      ```
 
 # Usage
 - Using the command `cflash` in the terminal, will start the flashing process. You will be asked several question before the flashing begins:

generate_javadoc.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# --- Generate JavaDoc for cflash ---
+# This script generates developer documentation using javadoc.
+# If JDK is missing, it prompts the user to install it using the detected package manager.
+
+set -e
+
+SRC_DIR="src/main/java"
+DOC_DIR="docs"
+
+# --- Detect package manager ---
+detect_package_manager() {
+	if command -v pacman >/dev/null 2>&1; then
+		echo "pacman"
+	elif command -v apt >/dev/null 2>&1; then
+		echo "apt"
+	elif command -v dnf >/dev/null 2>&1; then
+		echo "dnf"
+	elif command -v yum >/dev/null 2>&1; then
+		echo "yum"
+	elif command -v zypper >/dev/null 2>&1; then
+		echo "zypper"
+	elif command -v brew >/dev/null 2>&1; then
+		echo "brew"
+	elif command -v apk >/dev/null 2>&1; then
+		echo "apk"
+	elif command -v emerge >/dev/null 2>&1; then
+		echo "emerge"
+	else
+		echo ""
+	fi
+}
+
+# --- Generate JDK install command ---
+jdk_install_command() {
+	local pm="$1"
+	case "$pm" in
+		pacman) echo "pacman -Sy --noconfirm jdk-openjdk" ;;
+		apt) echo "apt update && apt install -y openjdk-21-jdk || apt install -y default-jdk" ;;
+		dnf) echo "dnf install -y java-21-openjdk-devel || dnf install -y java-latest-openjdk-devel" ;;
+		yum) echo "yum install -y java-21-openjdk-devel || yum install -y java-latest-openjdk-devel" ;;
+		zypper) echo "zypper install -y java-21-openjdk-devel || zypper install -y java-latest-openjdk-devel" ;;
+		brew) echo "brew install openjdk" ;;
+		apk) echo "apk add openjdk21" ;;
+		emerge) echo "emerge dev-java/openjdk-bin" ;;
+		*) echo "" ;;
+	esac
+}
+
+# --- Check for javadoc ---
+if ! command -v javadoc >/dev/null 2>&1; then
+	echo "Java Development Kit (JDK) with javadoc not found."
+	PM=$(detect_package_manager)
+
+	if [[ -z "$PM" ]]; then
+		echo "Please install the latest JDK manually and rerun this script."
+		exit 1
+	fi
+
+	CMD=$(jdk_install_command "$PM")
+	if [[ $EUID -ne 0 && "$PM" != "brew" ]]; then
+		echo "Please rerun this script with sudo if you want automatic JDK installation."
+		exit 1
+	fi
+
+	# Prompt user
+	read -rp "Do you want to run the following command to install the JDK? [$CMD] (y/n): " ANSWER
+	case "$ANSWER" in
+		y|Y)
+			echo "Installing JDK..."
+			eval "$CMD"
+			echo "JDK installed successfully."
+			;;
+		*)
+			echo "JDK installation cancelled. Please install manually and rerun."
+			exit 1
+			;;
+	esac
+fi
+
+# --- Check if source directory exists ---
+if [[ ! -d "$SRC_DIR" ]]; then
+	echo -e "\033[31mSource directory '$SRC_DIR' not found!"
+	echo "Please ensure you're running this script from the project root directory."
+	exit 1
+fi
+
+# --- Generate JavaDoc ---
+echo "Generating JavaDoc for cflash..."
+rm -rf "$DOC_DIR"
+mkdir -p "$DOC_DIR"
+
+# Check if Maven is available
+if command -v mvn >/dev/null 2>&1; then
+	echo "Using Maven to generate JavaDoc with dependencies..."
+	if mvn javadoc:javadoc -Dquiet=true > /dev/null 2>&1; then
+		# Copy generated docs from Maven location to our docs directory
+		if [[ -d "target/reports/apidocs" ]]; then
+			cp -r target/reports/apidocs/* "$DOC_DIR/"
+			echo -e "\033[32mJavaDoc generated successfully using Maven!"
+			echo -e "\033[0m→ Open file://$PWD/$DOC_DIR/index.html to view it."
+		else
+			echo -e "\033[31mMaven generated docs but couldn't find them in target/reports/apidocs"
+			exit 1
+		fi
+	else
+		echo -e "\033[31mMaven JavaDoc generation failed."
+		exit 1
+	fi
+else
+	echo "Maven not found. Attempting to generate JavaDoc without dependencies..."
+	# Try to download JLine dependency manually
+	JLINE_JAR="$HOME/.m2/repository/org/jline/jline/3.25.1/jline-3.25.1.jar"
+	if [[ -f "$JLINE_JAR" ]]; then
+		echo "Found JLine dependency in Maven local repository..."
+		CLASSPATH="$SRC_DIR:$JLINE_JAR"
+	else
+		echo "JLine dependency not found. JavaDoc may have missing links."
+		CLASSPATH="$SRC_DIR"
+	fi
+	
+	if javadoc -quiet -d "$DOC_DIR" \
+		-sourcepath "$SRC_DIR" \
+		-classpath "$CLASSPATH" \
+		-subpackages org.cametendo \
+		-private \
+		-author \
+		-version \
+		-doctitle "cflash - Disk Image Flashing Utility" \
+		-windowtitle "cflash Documentation" \
+		-bottom "Copyright © 2026 Cametendo. All rights reserved." > /dev/null 2>&1; then
+		echo -e "\033[32mJavaDoc generated successfully!"
+		echo -e "\033[0m→ Open file://$PWD/$DOC_DIR/index.html to view it."
+	else
+		echo -e "\033[31mJavaDoc generation failed. Install Maven for better dependency handling."
+		echo "Run: apt install maven (Ubuntu/Debian) or pacman -S maven (Arch)"
+		exit 1
+	fi
+fi

src/main/java/org/cametendo/BlockSize.java

@@ -1,10 +1,32 @@
 package org.cametendo;
 import java.util.Scanner;
 
+/**
+ * Utility class for managing block size configuration for disk flashing operations.
+ * 
+ * <p>This class provides methods to both interactively prompt users for block size selection
+ * and to map command-line inputs to valid block size values. The default block size is 4M.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class BlockSize {
     
+    /**
+     * Default block size string value.
+     * Set to "4M" as the default block size for flashing operations.
+     */
     public static String blockSizeString = "4M";
 
+    /**
+     * Maps user input to a valid block size value.
+     * 
+     * <p>Supports both numeric inputs (1-6) and string inputs (512K,1M,2M,4M,8M,16M).
+     * If the input is not recognized, returns the default block size.</p>
+     * 
+     * @param input User input string, either numeric (1-6) or block size string
+     * @return Valid block size string (512K, 1M, 2M, 4M, 8M, 16M, or default)
+     */
     public static String mapBlockSize(String input) {
         return switch (input) {
             case "1", "512K" -> "512K";
@@ -17,6 +39,15 @@ public class BlockSize {
         };
     }
     
+    /**
+     * Interactively prompts the user to select a block size.
+     * 
+     * <p>Displays a menu of available block sizes and maps the user's input
+     * to a valid block size value using {@link #mapBlockSize(String)}.</p>
+     * 
+     * @param UserInput Scanner object for reading user input
+     * @return The selected block size string
+     */
     static String blockSize(Scanner UserInput) {
         System.out.println("Choose a block size (Default: 4M)");
         System.out.println("512KB (1), 1M (2), 2M (3), 4M (4), 8M (5), 16M (6)");

src/main/java/org/cametendo/Dd.java

@@ -3,7 +3,26 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 
+/**
+ * Executes the dd command for disk flashing operations.
+ * 
+ * <p>This class handles the actual execution of the dd command with the configured
+ * parameters (input file, output device, block size, and output flags). It provides
+ * real-time output streaming and calls the OSDetector for completion messages.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class Dd {
+    
+    /**
+     * Executes the dd command with the configured parameters.
+     * 
+     * <p>Runs the dd command using sudo with the specified image file, target device,
+     * block size, and output flags. Streams the command output in real-time to show
+     * progress. Upon completion, calls {@link OSDetector#wishWell(String)} to display
+     * a completion message based on the image file name.</p>
+     */
     public static void dd() {
                 try {
             ProcessBuilder pb = new ProcessBuilder("sudo", "dd", "if=" + FilePathAdd.ImagePath, "of=" + StorageDeviceLister.fullPath, "bs=" + BlockSize.blockSizeString, "status=progress", "oflag=" + OflagHandler.oflagHandleString);

src/main/java/org/cametendo/FilePathAdd.java

@@ -1,4 +1,5 @@
 package org.cametendo;
+
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -9,10 +10,34 @@ import org.jline.reader.impl.completer.FileNameCompleter;
 import org.jline.terminal.Terminal;
 import org.jline.terminal.TerminalBuilder;
 
+/**
+ * Handles file path input and validation for disk image files.
+ * * <p>This class provides functionality to interactively prompt users for image file paths
+ * with tab completion support via JLine. It handles Unix-style tilde (~) expansion 
+ * to the user's home directory and validates that paths point to existing regular files.</p>
+ * * @author Cametendo
+ * @version 1.1
+ */
 public class FilePathAdd {
 
+    /**
+     * Stores the validated absolute path to the selected image file.
+     */
     public static String ImagePath = "";
     
+    /**
+     * Constant representing the current user's home directory path.
+     */
+    public static final String Home = System.getProperty("user.home");
+
+    /**
+     * Interactively prompts the user to select an image file path.
+     * * <p>Uses JLine for enhanced terminal interaction with {@link FileNameCompleter}.
+     * The method expands the tilde (~) character if present at the start of the string
+     * and validates that the resulting path is a regular file before returning.</p>
+     * * @return The validated absolute path to the selected image file
+     * @throws IOException If there are I/O errors during terminal setup or file resolution
+     */
     protected static String filePath() throws IOException {
         fileQuestion();
 
@@ -20,28 +45,48 @@ public class FilePathAdd {
         LineReader reader = LineReaderBuilder.builder().terminal(terminal).completer(new FileNameCompleter()).build();
 
         while (true) {
-            ImagePath = reader.readLine("Path: ").trim();
+            String input = reader.readLine("Path: ").trim();
 
-            if (ImagePath.isBlank()) {
+            if (input.isBlank()) {
                 System.out.println("Oops... You didn't specify a file!");
                 continue;
             }
 
-            Path path = Path.of(ImagePath);
+            // Expand tilde to the full home directory path
+            if (input.startsWith("~")) {
+                input = Home + input.substring(1);
+            }
+
+            Path path = Path.of(input);
 
             if (!Files.exists(path) || !Files.isRegularFile(path)) {
                 System.out.println("Invalid file! Please ensure the path points to an ISO / image file.");
                 continue;
             }
 
+            // Convert to a real, absolute path and return
+            ImagePath = path.toRealPath().toString();
             System.out.println("Using File: " + ImagePath);
             return ImagePath;
         }
     }
 
-    public static String validateAndGetFile(String ImagePath) {
+    /**
+     * Validates and returns the full path to an image file from a provided string.
+     * * <p>This is primarily used for validating command-line arguments. It supports
+     * tilde expansion and verifies file existence and type.</p>
+     * * @param inputPath Raw path string to validate
+     * @return Full validated absolute path, or {@code null} if the path is invalid or inaccessible
+     */
+    public static String validateAndGetFile(String inputPath) {
+        if (inputPath == null) return null;
+        
         try {
-            Path path = Path.of(ImagePath);
+            if (inputPath.startsWith("~")) {
+                inputPath = Home + inputPath.substring(1);
+            }
+
+            Path path = Path.of(inputPath);
             if (Files.exists(path) && Files.isRegularFile(path)) {
                 return path.toRealPath().toString();
             } else {
@@ -54,6 +99,9 @@ public class FilePathAdd {
         }
     }
 
+    /**
+     * Displays the prompt for file path input to the standard output.
+     */
     protected static void fileQuestion() {
         System.out.println("Please enter the FULL Path of your ISO / Image. (Tab-completion supported)");
     }

src/main/java/org/cametendo/Flasher.java

@@ -1,7 +1,26 @@
 package org.cametendo;
 import java.util.Scanner;
 
+/**
+ * Handles the final confirmation and execution of the disk flashing process.
+ * 
+ * <p>This class displays the current configuration to the user for confirmation
+ * before proceeding with the actual flashing operation using the dd command.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class Flasher {
+    
+    /**
+     * Displays the current flashing configuration and prompts for user confirmation.
+     * 
+     * <p>Shows the device path, image file path, block size, and output flag that will be used
+     * for the flashing operation. If the user confirms, proceeds with the flashing process
+     * by calling {@link Dd#dd()}. If the user cancels, exits the application.</p>
+     * 
+     * @param UserInput Scanner object for reading user confirmation
+     */
     public static void flasher(Scanner UserInput) {
         
         String input = "";

src/main/java/org/cametendo/GetHome.java

@@ -0,0 +1 @@
+	

src/main/java/org/cametendo/Greeting.java

@@ -2,17 +2,26 @@ package org.cametendo;
 
 import java.util.Scanner;
 
+/**
+ * Handles the initial greeting and user confirmation for the cflash application.
+ * 
+ * <p>This class provides a welcome message and prompts the user to confirm
+ * whether they want to proceed with flashing an image to a storage device.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class Greeting {
+    
+    /**
+     * Displays a welcome message and prompts for user confirmation.
+     * 
+     * <p>Shows the cflash welcome message and asks the user if they want to
+     * flash an image. If the user declines, exits the application.</p>
+     * 
+     * @param UserInput Scanner object for reading user confirmation
+     */
     public static void greeting(Scanner UserInput) {
         System.out.println("Welcome to cflash!");
-        System.out.println("Would you like to flash an image (Y/n)");
-        String input = UserInput.nextLine();
-		if (YesNo.check(input)) {
-			System.out.println("Please choose the to be flashed device (f. e. sda)");
-		} else {
-			System.out.println("Canceling...");
-			System.exit(0);
-		}
-
     }
 }

src/main/java/org/cametendo/Main.java

@@ -2,7 +2,43 @@ package org.cametendo;
 import java.io.IOException;
 import java.util.Scanner;
 
+/**
+ * Main entry point for the cflash application.
+ * 
+ * <p>cflash is a command-line utility for flashing disk images to storage devices.
+ * It supports both interactive mode and command-line argument mode for automation.</p>
+ * 
+ * <p>In interactive mode, the user is guided through device selection, file path input,
+ * block size configuration, and output flag selection. In command-line mode, all parameters
+ * can be specified as arguments for automated flashing.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class Main {
+
+    /**
+     * Main method that serves as the entry point for the cflash application.
+     * 
+     * <p>The application can operate in two modes:</p>
+     * <ul>
+     *   <li>Interactive mode: No arguments provided, user is guided through the process</li>
+     *   <li>Command-line mode: Four arguments provided for automated execution</li>
+     * </ul>
+     * 
+     * <p>Command-line arguments format:</p>
+     * <ol>
+     *   <li>Device name (e.g., "sda" without /dev/ prefix)</li>
+     *   <li>Image file path (absolute or relative path to ISO/image file)</li>
+     *   <li>Block size (1-6 or 512K,1M,2M,4M,8M,16M)</li>
+     *   <li>Output flag (1-4 or direct,dsync,sync,nocache)</li>
+     * </ol>
+     * 
+     * @param args Command-line arguments. If 4 arguments are provided, runs in automated mode.
+     *             If no arguments, runs in interactive mode.
+     * @throws InterruptedException If the flashing process is interrupted
+     * @throws IOException If there are I/O errors during device/file validation
+     */
     public static void main(String[] args) throws InterruptedException, IOException {
         Scanner UserInput = new Scanner(System.in);
         if (args.length == 4) {

src/main/java/org/cametendo/OSDetector.java

@@ -1,8 +1,27 @@
 package org.cametendo;
 import java.nio.file.Path;
 
+/**
+ * Detects operating system types from image file names and displays completion messages.
+ * 
+ * <p>This class analyzes the filename of disk images to identify the operating system
+ * and displays a personalized completion message with some fun descriptions for various
+ * Linux distributions, BSD variants, and other operating systems.</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class OSDetector {
 
+    /**
+     * Analyzes an image file path and displays a personalized completion message.
+     * 
+     * <p>Extracts the filename from the provided path and attempts to identify the
+     * operating system based on filename patterns. Displays a fun, personalized message
+     * wishing the user well with their new OS installation.</p>
+     * 
+     * @param imagePath Path to the image file that was flashed
+     */
     public static void wishWell(String imagePath) {
         String fileName = Path.of(imagePath).getFileName().toString().toLowerCase();
         
@@ -61,6 +80,8 @@ public class OSDetector {
             osName = "Haiku OS";
         } else if (fileName.contains("reactos")) {
             osName = "ReactOS";
+        } else if (fileName.contains("jgh")) {
+			osName = "JGH OS (Sauerkraut juice)";
 		}
         // Generic Fallbacks
         else if (fileName.contains("linux")) {
@@ -71,6 +92,6 @@ public class OSDetector {
             osName = "new OS";
         }
 
-        System.out.println("\nFlash complete! Have fun with your " + osName + " installation! 🚀");
+        System.out.println("\nFlash complete! Have fun with your " + osName + " installation!");
     }
 }

src/main/java/org/cametendo/OflagHandler.java

@@ -1,10 +1,32 @@
 package org.cametendo;
 import java.util.Scanner;
 
+/**
+ * Handles output flag (oflag) configuration for the dd command.
+ * 
+ * <p>This class provides functionality to both interactively prompt users for output flag selection
+ * and to map command-line inputs to valid oflag values. The default output flag is "direct".</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class OflagHandler {
 
+    /**
+     * Default output flag string value.
+     * Set to "direct" as the default output flag for dd operations.
+     */
     public static String oflagHandleString = "direct";
 
+    /**
+     * Maps user input to a valid output flag value.
+     * 
+     * <p>Supports both numeric inputs (1-4) and string inputs (direct,dsync,sync,nocache).
+     * If the input is not recognized, returns the default output flag.</p>
+     * 
+     * @param input User input string, either numeric (1-4) or output flag string
+     * @return Valid output flag string (direct, dsync, sync, nocache, or default)
+     */
     public static String mapOflagHandle(String input) {
         return switch (input) {
             case "1", "direct" -> "direct";
@@ -15,6 +37,15 @@ public class OflagHandler {
         };
     }
     
+    /**
+     * Interactively prompts the user to select an output flag.
+     * 
+     * <p>Displays a menu of available output flags and maps the user's input
+     * to a valid output flag value using {@link #mapOflagHandle(String)}.</p>
+     * 
+     * @param UserInput Scanner object for reading user input
+     * @return The selected output flag string
+     */
     static String Oflag(Scanner UserInput) {
         System.out.println("Choose an Oflag (Default: direct)");
         System.out.println("direct (1), dsync (2), sync (3), nocache (4)");

src/main/java/org/cametendo/StorageDeviceLister.java

@@ -1,62 +1,134 @@
 package org.cametendo;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.nio.file.Path;
 import java.util.Scanner;
 
+/**
+ * Handles storage device detection, listing, and validation for the flashing process.
+ * * <p>Includes safety checks to ensure we don't nuke a partition that's currently in use.
+ * Keeps the user in the loop with a more personal touch.</p>
+ * * @author Cametendo
+ * @version 1.1
+ */
 public class StorageDeviceLister {
 
     public static String device = "";
     public static String fullPath = "";
 
+    /**
+     * Guides the user through selecting a safe, unmounted storage device.
+     */
     protected static String deviceCheck(Scanner UserInput) {
         deviceList();
 
         while (true) {
-            device = UserInput.nextLine();
+            System.out.print("Target device: ");
+            device = UserInput.nextLine().trim();
+            
             if (device.isBlank()) {
                 System.out.println("Oops... Device name is empty. Did you missclick?");
                 continue;
             }
-            Path path = Path.of("/dev/" + device);
+
+            // Standardize path - allows entering 'sda' or '/dev/sda'
+            String checkPath = device.startsWith("/dev/") ? device : "/dev/" + device;
+            Path path = Path.of(checkPath);
 
             try {
                 fullPath = path.toRealPath().toString();
 
-                System.out.println("Using device: " + fullPath);
+                // Check if the user is about to break their system
+                if (isMounted(fullPath)) {
+                    System.out.println("Wait a second! " + fullPath + " is currently mounted.");
+                    System.out.println("I can't flash to a device that's in use. Unmount it and try again!");
+                    continue;
+                }
+                
+                System.out.println("Solid choice. Using device: " + fullPath);
                 return fullPath; 
 
             } catch (IOException e) {
-                System.out.println("Failed to access device! Invalid path or no access. Please try again.");
+                System.out.println("Hmm... I can't seem to find or access that device. Are you sure you have access to it?");
             }
         }
     }
 
-    public static String validateAndGetPath(String deviceName) {
+    /**
+     * Asks lsblk if the device or its children have an active mount point.
+     */
+    private static boolean isMounted(String devicePath) {
         try {
-            Path path = Path.of("/dev/" + deviceName);
-            return path.toRealPath().toString();
-        } catch (IOException e) {
-            System.out.println("Device not found. Invalid Path or no access.");
-            return null;
+            ProcessBuilder pb = new ProcessBuilder("lsblk", "-no", "MOUNTPOINT", devicePath);
+            Process process = pb.start();
+            
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    if (!line.trim().isEmpty()) {
+                        return true;
                     }
                 }
+            }
+            process.waitFor();
+        } catch (IOException | InterruptedException e) {
+            System.out.println("Warning: Mountstatus couldn't be verified");
+            return true; 
+        }
+        return false;
+    }
 
+    /**
+     * Lists devices with enough info for the user to make a smart decision.
+     */
     private static void deviceList() {
         try {
-            ProcessBuilder pb = new ProcessBuilder("lsblk");
+            System.out.println("Scanning for block devices...");
+            ProcessBuilder pb = new ProcessBuilder("lsblk", "-o", "NAME,SIZE,TYPE,RM,MOUNTPOINT");
             Process process = pb.start();
+            
             BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
             String line;
             while ((line = reader.readLine()) != null) {
                 System.out.println(line);
             }
             process.waitFor();
-            System.out.println("Please enter the name of your device (without /dev/):");
+            
+            System.out.println("Enter the name of your device (e.g., sdb or nvme1n1):");
 
         } catch (IOException | InterruptedException e) {
-            e.printStackTrace();
+            System.out.println("Failed to run lsblk. Do you have it installed.");
+        }
+    }
+
+	/**
+     * Validates a device path (e.g., from a CLI argument).
+     * * <p>Checks if the device exists, resolves the real path, and ensures 
+     * it isn't currently mounted before giving the green light.</p>
+     * * @param deviceName Device name (e.g., "sda" or "/dev/sda")
+     * @return Full validated path, or null if it's a bad idea to use it
+     */
+    public static String validateAndGetPath(String deviceName) {
+        if (deviceName == null || deviceName.isBlank()) return null;
+
+        try {
+            // Support both "sda" and "/dev/sda"
+            String checkPath = deviceName.startsWith("/dev/") ? deviceName : "/dev/" + deviceName;
+            Path path = Path.of(checkPath);
+            String resolvedPath = path.toRealPath().toString();
+
+            // Safety check for CLI arguments too!
+            if (isMounted(resolvedPath)) {
+                System.out.println("Hold up! " + resolvedPath + " is mounted. I won't let you flash it like that.");
+                return null;
+            }
+
+            return resolvedPath;
+        } catch (IOException e) {
+            System.out.println("Hmm... I couldn't find a device at '" + deviceName + "'. Is it plugged in?");
+            return null;
         }
     }
 }

src/main/java/org/cametendo/YesNo.java

@@ -1,5 +1,25 @@
 package org.cametendo;
+
+/**
+ * Utility class for parsing yes/no user responses.
+ * 
+ * <p>This class provides a simple method to interpret user input as a boolean
+ * value, accepting various forms of "yes" and treating everything else as "no".</p>
+ * 
+ * @author Cametendo
+ * @version 1.0
+ */
 public class YesNo {
+    
+    /**
+     * Parses user input to determine if it represents a "yes" response.
+     * 
+     * <p>Accepts "Y", "y", and empty string (default) as yes responses.
+     * All other inputs are treated as no responses.</p>
+     * 
+     * @param input User input string to parse
+     * @return true if the input represents a yes response, false otherwise
+     */
     public static boolean check(String input) {
         switch (input) {
             case "Y":