find all esp-idf instances and evaluate which one to process

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

updated according to changes in the scripts location

Documentation update to add the discovery command

Author: Hahihula

docs/src/cli_commands.md

@@ -30,7 +30,8 @@ These options can be used with any command:
 | `remove` | Remove a specific ESP-IDF version |
 | `purge` | Purge all ESP-IDF installations |
 | `import` | Import existing ESP-IDF installation using tools_set_config.json |
-| `discover` | Discover available ESP-IDF versions (not implemented yet) |
+| `discover` | Discover available ESP-IDF versions |
+| `gui` | Run the ESP-IDF Installer GUI with arguments passed through command line |
 
 ## Command Details
 
@@ -139,10 +140,10 @@ If `PATH` is not provided, the command will inform you that no config file was s
 Discover available ESP-IDF versions (not implemented yet).
 
 ```bash
-eim discover
+eim discover [PATH]
 ```
 
-This command is planned to discover ESP-IDF installations on your system but is not yet implemented.
+This command searches for previously installed ESP-IDF versions on your system. If PATH is not provided, the command will search from the root of the filesystem. For any found versions where automatic import is possible, they will be imported into EIM's management. For other found versions that cannot be automatically imported, the command will suggest the appropriate `eim install` command to allow the user to manually reinstall them.
 
 ## Examples
 

src-tauri/src/cli/cli_args.rs

@@ -66,7 +66,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;
@@ -9,7 +10,11 @@ use config::ConfigError;
 use helpers::generic_input;
 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;
@@ -315,13 +320,107 @@ pub async fn run_cli(cli: Cli) -> anyhow::Result<()> {
                 }
             }
         }
-        Commands::Discover => {
-            // TODO:Implement version discovery
-            unimplemented!("Version discovery not implemented yet");
-            println!("Discovering available versions... (This can take couple of minutes)");
-            let idf_dirs = idf_im_lib::version_manager::find_esp_idf_folders("/");
+        Commands::Discover {path  } => {
+            info!("Discovering available versions... (This can take couple of minutes)");
+            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 {
+                info!("Found {} IDF directories:", idf_dirs.len());
+            }
+            let config = match idf_im_lib::version_manager::get_esp_ide_config() {
+              Ok(config) => {
+                if config.idf_installed.is_empty() {
+                  debug!(
+                      "No versions found. Every discovered version can be imported."
+                  );
+                }
+                config
+              }
+              Err(_err) => {
+                debug!("No ide config found. New will be created.");
+                IdfConfig::default()
+              }
+            };
+            let mut paths_to_add = vec![];
             for dir in idf_dirs {
-                println!("Found IDF directory: {}", dir);
+              info!("- {} ", &dir);
+              if config.clone().is_path_in_config(dir.clone()) {
+                info!("Already present!");
+              } else {
+                info!("Can be added...");
+                paths_to_add.push(dir);
+              }
+            }
+            if paths_to_add.is_empty() {
+                info!("No new IDF directories found to add.");
+                return Ok(());
+            } else {
+                info!("Found {} new IDF directories available to add:", paths_to_add.len());
+                info!("You can add them using `eim install` command with the `--path` option.");
             }
             Ok(())
         }

src-tauri/src/gui/mod.rs

@@ -169,37 +169,6 @@ impl ToolSetup {
     }
 }
 
-// async fn install_single_version(
-//     app_handle: AppHandle,
-//     settings: &Settings,
-//     version: String,
-// ) -> Result<(), Box<dyn std::error::Error>> {
-//     info!("Installing IDF version: {}", version);
-
-//     let version_path = prepare_installation_directories(app_handle.clone(), settings, &version)?;
-//     let idf_path = version_path.clone().join("esp-idf");
-//     download_idf(&app_handle, settings, &version, &idf_path).await?;
-//     let export_vars = setup_tools(&app_handle, settings, &idf_path, &version).await?;
-//     let tools_install_path = version_path.clone().join(
-//         settings
-//             .tool_install_folder_name
-//             .clone()
-//             .unwrap_or_default(),
-//     );
-//     let idf_python_env_path = tools_install_path.clone().join("python").join(&version).join("venv");
-//     let activation_script_path = settings.esp_idf_json_path.clone().unwrap_or_default();
-//     idf_im_lib::single_version_post_install(
-//         &activation_script_path,
-//         idf_path.to_str().unwrap(),
-//         &version,
-//         tools_install_path.to_str().unwrap(),
-//         export_vars,
-//         Some(idf_python_env_path.to_str().unwrap()),
-//     );
-
-//     Ok(())
-// }
-
 // Helper function to check if a process is running on Windows
 #[cfg(target_os = "windows")]
 fn is_process_running(pid: u32) -> bool {

src-tauri/src/lib/idf_config.rs

@@ -37,6 +37,18 @@ pub struct IdfConfig {
     pub version: Option<String>,
 }
 
+impl Default for IdfConfig {
+  fn default() -> Self {
+      IdfConfig {
+        git_path: crate::utils::get_git_path().unwrap(),
+        idf_installed: [].to_vec(),
+        idf_selected_id: "".to_string(),
+        eim_path: None,
+        version: Some(IDF_CONFIG_FILE_VERSION.to_string()),
+      }
+  }
+}
+
 impl IdfConfig {
     /// Saves the configuration to a file.
     ///
@@ -226,6 +238,10 @@ impl IdfConfig {
         }
     }
 
+    pub fn is_path_in_config(self, path:String) -> bool {
+      self.idf_installed.iter().find(|i| i.path == path).is_some()
+    }
+
     /// Removes an IDF installation from the configuration.
     ///
     /// This function searches for an installation matching the given identifier
@@ -261,9 +277,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> {