refactor: restructure CLI with optimization flags and debug modes (#242)

Refactor command-line interface to support optimization levels and
comprehensive debug output modes with improved error handling.

Changes:
- Add library target configuration to Cargo.toml:
  - Expose wavec as both binary and library
  - Enable path specification for lib.rs
- Refactor CLI argument parsing:
  - Extract commands module with handle_run/handle_build functions
  - Add DebugFlags struct for modular debug output control
  - Support optimization flags (-O0, -O1, -O2, -O3, -Oz, -Ofast)
  - Remove verbose flag in favor of debug modes
- Implement debug output system:
  - --debug-wave=tokens: Display lexer token stream
  - --debug-wave=ast: Show abstract syntax tree
  - --debug-wave=ir: Print LLVM intermediate representation
  - --debug-wave=mc: Display machine code path
  - --debug-wave=hex: Dump binary in hexadecimal format
  - --debug-wave=all: Enable all debug outputs
- Update compilation pipeline:
  - Pass optimization flag to clang invocation
  - Thread debug flags through runner and backend
  - Remove standalone CompilerConfig system
- Simplify runner.rs execution flow:
  - Direct output instead of buffering
  - Remove unused import resolution code
  - Pass opt_flag and debug flags to backend
- Add dedicated errors module:
  - Define CliError enum (NotEnoughArgs, UnknownCommand, MissingArgument)
  - Implement Display trait for formatted error messages
- Streamline help output:
  - Group commands, optimization, and debug options
  - Add practical usage examples
  - Remove verbose mode information

Examples:
  wavec run test.wave
  wavec run -O3 test.wave
  wavec run --debug-wave=ir test.wave
  wavec run -Ofast --debug-wave=all test.wave

The refactored CLI provides better developer experience with granular
control over optimization and debugging output.

Author: LunaStev

Cargo.toml

@@ -3,6 +3,10 @@ name = "wavec"
 version = "0.1.5-pre-beta"
 edition = "2021"
 
+[lib]
+name = "wavec"
+path = "src/lib.rs"
+
 # [target.x86_64-apple-darwin]
 # linker = "clang"
 # [target.aarch64-apple-darwin]

llvm_temporary/src/llvm_temporary/llvm_backend.rs

@@ -2,19 +2,14 @@ use std::process::Command;
 use std::fs;
 use std::path::Path;
 
-pub fn compile_ir_to_machine_code(ir: &str, file_stem: &str) -> String {
-    let target_dir = Path::new("target");
-    if !target_dir.exists() {
-        fs::create_dir_all(target_dir).expect("Unable to create target directory");
-    }
-
+pub fn compile_ir_to_machine_code(ir: &str, file_stem: &str, opt_flag: &str) -> String {
     let ir_path = "target/temp.ll";
-    fs::write(ir_path, ir).expect("Unable to write IR to file");
+    fs::write(ir_path, ir).unwrap();
 
     let machine_code_path = format!("target/{}", file_stem);
 
     let output = Command::new("clang")
-        .arg("-O2")
+        .arg(opt_flag)
         .arg("-o")
         .arg(&machine_code_path)
         .arg(ir_path)

src/commands.rs

@@ -0,0 +1,67 @@
+use std::path::Path;
+use crate::{compile_and_img, compile_and_run};
+use crate::errors::CliError;
+
+#[derive(Default)]
+pub struct DebugFlags {
+    pub ast: bool,
+    pub tokens: bool,
+    pub ir: bool,
+    pub mc: bool,
+    pub hex: bool,
+}
+
+impl DebugFlags {
+    pub fn apply(&mut self, mode: &str) {
+        match mode {
+            "tokens" => self.tokens = true,
+            "ast" => self.ast = true,
+            "ir" => self.ir = true,
+            "mc" => self.mc = true,
+            "hex" => self.hex = true,
+            "all" => {
+                self.ast = true;
+                self.ir = true;
+                self.mc = true;
+                self.hex = true;
+            }
+            _ => {}
+        }
+    }
+}
+
+pub fn handle_run(
+    file_path: &Path,
+    opt_flag: &str,
+    debug: &DebugFlags,
+) -> Result<(), CliError> {
+    unsafe {
+        compile_and_run(file_path, opt_flag, debug);
+    }
+    Ok(())
+}
+
+pub fn handle_build(
+    file_path: &Path,
+    opt_flag: &str,
+    debug: &DebugFlags,
+) -> Result<(), CliError> {
+    println!("Building with {}...", opt_flag);
+
+    unsafe {
+        compile_and_img(file_path);
+    }
+
+    if debug.mc {
+        println!("Machine code built successfully.");
+    }
+
+    Ok(())
+}
+
+pub fn img_run(file_path: &Path) -> Result<(), CliError> {
+    unsafe {
+        compile_and_img(file_path);
+    }
+    Ok(())
+}

src/compiler_config.rs

@@ -0,0 +1,25 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum CliError {
+    NotEnoughArgs,
+    UnknownCommand(String),
+    MissingArgument {
+        command: &'static str,
+        expected: &'static str,
+    },
+}
+
+impl fmt::Display for CliError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CliError::NotEnoughArgs => write!(f, "Error: Not enough arguments"),
+            CliError::UnknownCommand(cmd) => write!(f, "Error: Unknown command '{}'", cmd),
+            CliError::MissingArgument { command, expected } => write!(
+                f,
+                "Error: Missing argument for '{}'. Expected: {}",
+                command, expected
+            ),
+        }
+    }
+}

src/errors.rs

@@ -1,12 +1,16 @@
 pub mod runner;
 pub mod version;
+pub mod commands;
+pub mod errors;
 
 use std::path::Path;
 use colorex::Colorize;
 use crate::version::get_os_pretty_name;
 
-pub unsafe fn compile_and_run(path: &Path) {
-    runner::run_wave_file(path);
+use commands::DebugFlags;
+
+pub unsafe fn compile_and_run(path: &Path, opt_flag: &str, debug: &DebugFlags) {
+    runner::run_wave_file(path, opt_flag, debug);
 }
 
 pub unsafe fn compile_and_img(path: &Path) {
@@ -16,8 +20,10 @@ pub unsafe fn compile_and_img(path: &Path) {
 pub fn version_wave() {
     let os = format!("({})", get_os_pretty_name()).color("117,117,117");
 
-    println!("{} {} {}",
-             "wavec".color("2,161,47"),
-             version::version().color("2,161,47"),
-             os);
+    println!(
+        "{} {} {}",
+        "wavec".color("2,161,47"),
+        version::version().color("2,161,47"),
+        os
+    );
 }