feat(core): better error context (#85)

Author: load1n9

cli/src/error.rs

@@ -322,24 +322,3 @@ pub fn read_file_with_context(path: &std::path::Path) -> Result<String> {
         _ => AndromedaError::file_read_error(path.to_path_buf(), e),
     })
 }
-
-/// Extract meaningful error information from Nova VM errors
-pub fn extract_runtime_error_info(
-    error_string: &str,
-    _file_path: Option<String>,
-) -> (String, Option<u32>, Option<u32>) {
-    for part in error_string.split_whitespace() {
-        if let Some(colon_pos) = part.rfind(':') {
-            if let Some(second_colon) = part[..colon_pos].rfind(':') {
-                let line_str = &part[second_colon + 1..colon_pos];
-                let col_str = &part[colon_pos + 1..];
-
-                if let (Ok(line), Ok(col)) = (line_str.parse::<u32>(), col_str.parse::<u32>()) {
-                    return (error_string.to_string(), Some(line), Some(col));
-                }
-            }
-        }
-    }
-
-    (error_string.to_string(), None, None)
-}

cli/src/main.rs

@@ -17,7 +17,7 @@ mod run;
 mod styles;
 use run::run;
 mod error;
-use error::{AndromedaError, Result, init_error_reporting, print_error};
+use error::{Result, init_error_reporting, print_error};
 mod format;
 use format::format_file;
 mod helper;
@@ -108,8 +108,11 @@ enum Command {
 }
 
 fn main() {
-    // Initialize beautiful error reporting
+    // Initialize beautiful error reporting from CLI
     init_error_reporting();
+    // Also initialize the enhanced error reporting from core
+    andromeda_core::ErrorReporter::init();
+
     if let Err(error) = run_main() {
         print_error(error);
         std::process::exit(1);
@@ -137,7 +140,7 @@ fn run_main() -> Result<()> {
         .enable_time()
         .build()
         .map_err(|e| {
-            AndromedaError::config_error(
+            error::AndromedaError::config_error(
                 "Failed to initialize async runtime".to_string(),
                 None,
                 Some(Box::new(e)),
@@ -161,7 +164,7 @@ fn run_main() -> Result<()> {
             }
             Command::Compile { path, out } => {
                 compile(out.as_path(), path.as_path()).map_err(|e| {
-                    AndromedaError::compile_error(
+                    error::AndromedaError::compile_error(
                         format!("Compilation failed: {e}"),
                         path.clone(),
                         out.clone(),
@@ -176,8 +179,9 @@ fn run_main() -> Result<()> {
                 expose_internals,
                 print_internals,
                 disable_gc,
-            } => run_repl(expose_internals, print_internals, disable_gc)
-                .map_err(|e| AndromedaError::repl_error(format!("REPL failed: {e}"), Some(e))),
+            } => run_repl(expose_internals, print_internals, disable_gc).map_err(|e| {
+                error::AndromedaError::repl_error(format!("REPL failed: {e}"), Some(e))
+            }),
             Command::Fmt { paths } => {
                 let files_to_format = find_formattable_files(&paths)?;
 
@@ -201,7 +205,7 @@ fn run_main() -> Result<()> {
                 version,
                 dry_run,
             } => upgrade::run_upgrade(force, version, dry_run).map_err(|e| {
-                AndromedaError::runtime_error(
+                error::AndromedaError::runtime_error(
                     format!("Upgrade failed: {e}"),
                     None,
                     None,
@@ -213,7 +217,7 @@ fn run_main() -> Result<()> {
     });
     match rt.block_on(nova_thread) {
         Ok(result) => result,
-        Err(e) => Err(AndromedaError::config_error(
+        Err(e) => Err(error::AndromedaError::config_error(
             "Runtime execution failed".to_string(),
             None,
             Some(Box::new(e)),

cli/src/run.rs

@@ -2,8 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use crate::error::{AndromedaError, Result, extract_runtime_error_info, read_file_with_context};
-use andromeda_core::{HostData, Runtime, RuntimeConfig, RuntimeFile};
+use crate::error::{Result, read_file_with_context};
+use andromeda_core::{
+    AndromedaError, ErrorReporter, HostData, Runtime, RuntimeConfig, RuntimeFile,
+};
 use andromeda_runtime::{
     recommended_builtins, recommended_eventloop_handler, recommended_extensions,
 };
@@ -12,7 +14,7 @@ use andromeda_runtime::{
 pub fn run(verbose: bool, no_strict: bool, files: Vec<RuntimeFile>) -> Result<()> {
     // Validate that we have files to run
     if files.is_empty() {
-        return Err(AndromedaError::invalid_argument(
+        return Err(crate::error::AndromedaError::invalid_argument(
             "files".to_string(),
             "at least one file path".to_string(),
             "empty list".to_string(),
@@ -24,7 +26,7 @@ pub fn run(verbose: bool, no_strict: bool, files: Vec<RuntimeFile>) -> Result<()
         if let RuntimeFile::Local { path } = file {
             let file_path = std::path::Path::new(path);
             if !file_path.exists() {
-                return Err(AndromedaError::file_not_found(
+                return Err(crate::error::AndromedaError::file_not_found(
                     file_path.to_path_buf(),
                     std::io::Error::new(std::io::ErrorKind::NotFound, "File not found"),
                 ));
@@ -38,6 +40,15 @@ pub fn run(verbose: bool, no_strict: bool, files: Vec<RuntimeFile>) -> Result<()
     let (macro_task_tx, macro_task_rx) = std::sync::mpsc::channel();
     let host_data = HostData::new(macro_task_tx);
 
+    // Store file information before moving files into runtime
+    let first_file_info = files.first().and_then(|file| {
+        if let RuntimeFile::Local { path } = file {
+            Some(path.clone())
+        } else {
+            None
+        }
+    });
+
     let runtime = Runtime::new(
         RuntimeConfig {
             no_strict,
@@ -74,33 +85,45 @@ pub fn run(verbose: bool, no_strict: bool, files: Vec<RuntimeFile>) -> Result<()
                             .to_string()
                     });
 
-            // Try to extract file path from the error context if available
-            let file_path =
-                runtime_output
-                    .agent
-                    .run_in_realm(&runtime_output.realm_root, |_agent, _gc| {
-                        // This is a simplified approach - Nova might provide better error context in the future
-                        None::<String>
-                    });
+            // Try to get the first file from our runtime files to show source context
+            let (file_path, source_content) = if let Some(path) = first_file_info {
+                match read_file_with_context(std::path::Path::new(&path)) {
+                    Ok(content) => (Some(path), Some(content)),
+                    Err(_) => (Some(path), None),
+                }
+            } else {
+                (None, None)
+            };
 
-            // Extract line and column information from the error message
-            let (clean_message, line, column) =
-                extract_runtime_error_info(&error_message, file_path.clone());
+            // Create an enhanced runtime error with source context if available
+            let enhanced_error = if let (Some(path), Some(content)) = (file_path, source_content) {
+                // Try to find a better source span by looking for the error location in the message
+                let source_span = if error_message.contains("fertch") {
+                    // Find the position of 'fertch' in the source code
+                    if let Some(pos) = content.find("fertch") {
+                        miette::SourceSpan::new(pos.into(), 6) // 'fertch' is 6 characters
+                    } else {
+                        miette::SourceSpan::new(0.into(), 1)
+                    }
+                } else {
+                    miette::SourceSpan::new(0.into(), 1)
+                };
 
-            // Try to get source content if we have a file path
-            let source_content = if let Some(ref path) = file_path {
-                read_file_with_context(std::path::Path::new(path)).ok()
+                AndromedaError::runtime_error_with_location(
+                    error_message.clone(),
+                    &content,
+                    &path,
+                    source_span,
+                )
             } else {
-                None
+                AndromedaError::runtime_error(error_message.clone())
             };
 
-            Err(AndromedaError::runtime_error(
-                clean_message,
-                file_path,
-                line,
-                column,
-                source_content,
-            ))
+            // Print the enhanced error using our error reporting system
+            ErrorReporter::print_error(&enhanced_error);
+
+            // Exit directly instead of returning another error to avoid double printing
+            std::process::exit(1);
         }
     }
 }