IDF installed using eim or eclipse can be discovered

parsing function for esp_idf.json file added

POSIX discovery mvp

updated activation script creation

improved export paths in old version discovery

added tool_set.json file parsing to the discovery

returned the parse_tool_set_config back to working state

Author: Hahihula

src-tauri/src/cli/cli_args.rs

@@ -65,7 +65,10 @@ pub enum Commands {
     },
 
     /// Discover available ESP-IDF versions (not implemented yet)
-    Discover,
+    Discover {
+        #[arg(help = "Discover available ESP-IDF versions and imports them")]
+        path: Option<String>,
+    },
 
     /// Remove specific ESP-IDF version
     Remove {

src-tauri/src/cli/mod.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::path::PathBuf;
 
 use anyhow::Context;
@@ -11,6 +12,9 @@ use helpers::generic_select;
 use idf_im_lib::get_log_directory;
 use idf_im_lib::idf_config::IdfConfig;
 use idf_im_lib::settings::Settings;
+use idf_im_lib::utils::find_by_name_and_extension;
+use idf_im_lib::utils::parse_esp_idf_json;
+use idf_im_lib::utils::try_import_existing_idf;
 use idf_im_lib::version_manager::remove_single_idf_version;
 use idf_im_lib::version_manager::select_idf_version;
 use log::debug;
@@ -316,9 +320,73 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                 }
             }
         }
-        Commands::Discover => {
+        Commands::Discover {path  } => {
             info!("Discovering available versions... (This can take couple of minutes)");
-            let idf_dirs = idf_im_lib::version_manager::find_esp_idf_folders("/tmp");
+            // TODO: add warning and confirmation
+            let path = path.unwrap_or_else(|| {
+                let default_path = match std::env::consts::OS {
+                    "windows" => {
+                        "C:\\".to_string()
+                    }
+                    _ => {
+                        "/".to_string()
+                    }
+                };
+
+
+                debug!("No path provided, using default: {}", default_path);
+                default_path
+            });
+            // first parse existing esp_idf.json (using parse_esp_idf_json) || previous VSCode installations
+            info!("Searching for esp_idf.json files...");
+            let search_patch = Path::new(&path);
+            let esp_idf_json_path = find_by_name_and_extension(
+              search_patch,
+              "esp_idf",
+              "json",
+            );
+            if esp_idf_json_path.is_empty() {
+                info!("No esp_idf.json found");
+            } else {
+                info!("Found {} esp_idf.json files:", esp_idf_json_path.len());
+            }
+            for path in esp_idf_json_path {
+                info!("- {} ", &path);
+               match parse_esp_idf_json(&path) {
+                    Ok(_) => {
+                        info!("Parsed config: {:?}", path);
+                    }
+                    Err(err) => {
+                        info!("Failed to parse esp_idf.json: {}", err);
+                    }
+                }
+            }
+            // second try to find tool_set_config.json (using parse_tool_set_config) || previous Eclipse installations
+            info!("Searching for tool_set_config.json files...");
+            let tool_set_config_path = find_by_name_and_extension(
+                search_patch,
+                "tool_set_config",
+                "json",
+            );
+            if tool_set_config_path.is_empty() {
+                info!("No tool_set_config.json found");
+            } else {
+                info!("Found {} tool_set_config.json files:", tool_set_config_path.len());
+            }
+            for path in tool_set_config_path {
+                info!("- {} ", &path);
+                match idf_im_lib::utils::parse_tool_set_config(&path) {
+                    Ok(_) => {
+                        info!("Parsed config: {:?}", path);
+                    }
+                    Err(err) => {
+                        info!("Failed to parse tool_set_config.json: {}", err);
+                    }
+                }
+            }
+            // third try to find IDF directories (using find_esp_idf_folders) || previous instalation from cli
+            info!("Searching for any other IDF directories...");
+            let idf_dirs = idf_im_lib::version_manager::find_esp_idf_folders(&path);
             if idf_dirs.is_empty() {
                 info!("No IDF directories found");
             } else {
@@ -349,6 +417,17 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
               }
 
             }
+            // TODO: ask the user to select which IDFs to add
+            for p in paths_to_add {
+              match try_import_existing_idf(&p) {
+                Ok(_) => {
+                  info!("Added to config: {}", p);
+                }
+                Err(err) => {
+                  error!("Failed to add: {} - reason :{}",p, err);
+                }
+              }
+            }
             Ok(())
         }
         Commands::Import { path } => match path {

src-tauri/src/lib/idf_config.rs

@@ -260,9 +260,6 @@ impl IdfConfig {
         }
     }
 
-    pub fn is_path_in_config(self, path:String) -> bool {
-      self.idf_installed.iter().find(|i| i.path == path).is_some()
-    }
 }
 
 pub fn parse_idf_config<P: AsRef<Path>>(path: P) -> Result<IdfConfig> {