added a remove project function, and layed the framework for prompting

for user interaction.

src/lib.rs

@@ -3,10 +3,10 @@ use ratatui::crossterm::event;
 use rhai::{AST, Dynamic, Engine, Scope};
 use std::collections::HashMap;
 use std::error::Error;
-use std::fs::{File, create_dir_all, read_dir, read_to_string, remove_dir_all};
-use std::io::{self, Write};
+use std::fs::{self, File, create_dir_all, read_dir, read_to_string, remove_dir_all};
+use std::io::{self, BufRead, BufReader, Write};
 use std::path::PathBuf;
-use std::process::Command;
+use std::process::{Command, Stdio};
 use std::sync::mpsc::Receiver;
 use std::sync::{Arc, mpsc::Sender, mpsc::channel};
 
@@ -28,6 +28,7 @@ pub struct AppState {
     pub curent_intput: String,
     pub module_loader: ModuleLoader,
     pub output_scroll: u16,
+    pub prompt: Prompt,
 }
 
 impl AppState {
@@ -53,6 +54,11 @@ impl AppState {
                 curent_intput: String::new(),
                 module_loader: ModuleLoader::new(),
                 output_scroll: 0,
+                prompt: Prompt {
+                    action: None,
+                    responses: Vec::new(),
+                    completed: false,
+                },
             },
             main_rx,
         )
@@ -99,6 +105,24 @@ impl AppState {
                             let mut new_project = Project::new();
                             new_project.config_folder(conf_file.path());
                             new_project.load_config()?;
+                            let template_box = self.config.get("template_box").unwrap();
+                            let tools = self.config.get("tools").unwrap();
+                            let db = DistroBox {
+                                name: format!(
+                                    "{}-{}-{}",
+                                    template_box,
+                                    new_project.org_name.clone(),
+                                    new_project.name.clone()
+                                ),
+                                volumes: vec![
+                                    new_project.files.display().to_string(),
+                                    new_project.notes.display().to_string(),
+                                    tools.clone(),
+                                ],
+                                created: false,
+                                template: template_box.clone(),
+                            };
+                            new_project.db = Some(db);
                             self.projects.push(new_project);
                         }
                     }
@@ -165,6 +189,10 @@ impl AppState {
                     "notes: {}",
                     &self.projects[self.selected_project].notes.display()
                 ));
+                out_vec.push(format!(
+                    "config_folder: {}",
+                    &self.projects[self.selected_project].config_folder.display()
+                ));
                 if let Some(db) = self.projects[self.selected_project].db.clone() {
                     out_vec.push(format!("distrobox: {}", db.name));
                 }
@@ -178,23 +206,60 @@ impl AppState {
                 }
             }
             "promote_project" | "pp" => {
-                match self.promote_project() {
-                    Ok(out) => {
-                        let _ = self.main_tx.send(ToolMessage::Output(out));
-                    }
-                    Err(e) => {
-                        let _ = self
-                            .main_tx
-                            .send(ToolMessage::Output(format!("error promoting project! {e}")));
-                    }
-                };
+                self.promote_project()?;
+            }
+            "remove_project_confirm" => {
+                let project = self.projects[self.selected_project].clone();
+                let mut config_file = project.config_folder.clone();
+                config_file.pop();
+                if let Err(e) = remove_dir_all(&project.config_folder) {
+                    let _ = self.main_tx.send(ToolMessage::Output(format!(
+                        "failed to delete config: {e} on {}",
+                        &project.config_folder.display()
+                    )));
+                }
+                if let Err(e) = remove_dir_all(&project.notes) {
+                    let _ = self.main_tx.send(ToolMessage::Output(format!(
+                        "failed to delete notes: {e} on {}",
+                        &project.notes.display()
+                    )));
+                }
+                if let Err(e) = remove_dir_all(&project.files) {
+                    let _ = self.main_tx.send(ToolMessage::Output(format!(
+                        "failed to delete files: {e} on {}",
+                        &project.files.display()
+                    )));
+                }
+                self.projects.remove(self.selected_project);
+                self.prompt.action = None;
+                self.prompt.responses.clear();
+                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                    "{}-{} was sucessfully removed!",
+                    project.org_name, project.name
+                )));
+            }
+            "remove_project" | "rp" => {
+                let project = self.projects[self.selected_project].clone();
+                if project.name == "default" && project.org_name == "default" {
+                    let _ = self.main_tx.send(ToolMessage::Output(
+                        "The default project must remain. Canceling.".to_string(),
+                    ));
+                    self.prompt.action = None;
+                } else {
+                    self.prompt.action = Some(ToolMessage::RemoveProject);
+                    let _ = self.main_tx.send(ToolMessage::Output(format!(
+                        "{}, {} and all contents will be deleted. Continue? (y/N)",
+                        project.files.display(),
+                        project.notes.display()
+                    )));
+                }
             }
             _ => {
                 let ast = self
                     .module_loader
                     .asts
                     .get(command_name)
-                    .ok_or_else(|| format!("AST not found for command: {}", command_name))?
+                    .ok_or_else(|| format!("Command not found: {}", command_name))?
                     .clone();
 
                 let engine = Arc::clone(&self.module_loader.engine);
@@ -284,33 +349,98 @@ impl AppState {
 
     pub fn new_project(&mut self, org: String, name: String) -> Result<(), Box<dyn Error>> {
         let template_box = self.config.get("template_box").unwrap();
-        let tools_dir = self.config.get("tools").unwrap();
         let project_files = PathBuf::from(self.config.get("upcoming_files").unwrap())
             .join(format!("{}/{}", org, name));
         let project_notes = PathBuf::from(self.config.get("upcoming_notes").unwrap())
             .join(format!("{}/{}", org, name));
-        create_dir_all(&project_files)?;
-        create_dir_all(&project_notes)?;
+        let mut template_path = self.config_file.clone();
+        let mut project_conf_folder = self.config_file.clone();
+        let tools = self.config.get("tools").unwrap();
+        template_path.pop();
+        template_path.push("note_templates");
+        project_conf_folder.pop();
+        project_conf_folder.push(format!("projects/{}-{}", org, name));
+        let mut options = CopyOptions::new();
+        options.overwrite = true;
+        match create_dir_all(&project_files) {
+            Ok(_) => {}
+            Err(e) => {
+                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                    "error making project files! {e} on {}",
+                    project_files.display()
+                )));
+            }
+        }
+        match create_dir_all(&project_notes) {
+            Ok(_) => {}
+            Err(e) => {
+                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                    "error making project notes! {e} on {}",
+                    project_notes.display()
+                )));
+            }
+        }
+        match create_dir_all(&project_conf_folder) {
+            Ok(_) => {}
+            Err(e) => {
+                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                    "error making config folder! {e} on {}",
+                    project_conf_folder.display()
+                )));
+            }
+        }
+        for entry in read_dir(template_path)? {
+            let entry = entry?;
+            let template_name_os = entry.file_name();
+            let template_name = template_name_os.to_string_lossy();
+            if name.clone().contains(template_name.as_ref()) {
+                for entry in read_dir(entry.path())? {
+                    let entry = entry?;
+                    let file_name_os = entry.file_name();
+                    let file_name = file_name_os.to_string_lossy();
+                    if entry.file_type()?.is_dir() {
+                        let dest = project_notes.join(file_name.as_ref());
+                        match copy(entry.path(), dest, &options) {
+                            Ok(_) => {}
+                            Err(e) => {
+                                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                                    "error copying note template! {e}"
+                                )));
+                            }
+                        }
+                    } else {
+                        match fs::copy(entry.path(), project_notes.join(file_name.as_ref())) {
+                            Ok(_) => {}
+                            Err(e) => {
+                                let _ = self.main_tx.send(ToolMessage::Output(format!(
+                                    "error copying note template! {e}"
+                                )));
+                            }
+                        }
+                    }
+                }
+            }
+        }
         let db = DistroBox {
             name: format!("{}-{}-{}", template_box, org, name),
             volumes: vec![
                 project_files.display().to_string(),
                 project_notes.display().to_string(),
-                tools_dir.clone(),
+                tools.to_string(),
             ],
             created: false,
-            template: template_box.clone(),
+            template: template_box.to_string(),
+        };
+        let mut new_project = Project {
+            org_name: org,
+            name: name,
+            notes: project_notes,
+            files: project_files,
+            hosts: Vec::new(),
+            config_folder: project_conf_folder,
+            current: false,
+            db: Some(db),
         };
-        let mut new_project = Project::new();
-        let mut project_conf_folder = self.config_file.clone();
-        project_conf_folder.pop();
-        project_conf_folder.push(format!("projects/{}-{}", org, name));
-        new_project.config_folder(project_conf_folder);
-        new_project.name = name;
-        new_project.db = Some(db);
-        new_project.org_name(org);
-        new_project.files(project_files);
-        new_project.notes(project_notes);
         new_project.save_config()?;
         self.projects.push(new_project);
         return Ok(());
@@ -324,6 +454,8 @@ impl AppState {
         let new_notes_path = PathBuf::from(self.config.get("current_notes").unwrap())
             .join(format!("{}/{}", new_project.org_name, new_project.name));
         let mut options = CopyOptions::new();
+        create_dir_all(&new_files_path)?;
+        create_dir_all(&new_notes_path)?;
         options.overwrite = true;
         copy(new_project.files.clone(), new_files_path.clone(), &options)?;
         copy(new_project.notes.clone(), new_notes_path.clone(), &options)?;
@@ -347,8 +479,8 @@ impl AppState {
                 new_notes_path.display().to_string(),
                 self.config.get("tools").unwrap().to_string(),
             ];
-            db.create()?;
             new_project.db = Some(db);
+            let _ = self.main_tx.send(ToolMessage::RebuildDB);
         }
         self.projects[self.selected_project] = new_project;
         return Ok(return_string);
@@ -563,7 +695,9 @@ pub enum ToolMessage {
     Input(String),
     Output(String),
     UpdateHost(Host),
-    UpdateProject(Project),
+    RebuildDB,
+    UpdateProject(usize, Project),
+    RemoveProject,
 }
 
 #[derive(Clone, Debug)]
@@ -747,7 +881,7 @@ pub struct DistroBox {
 }
 
 impl DistroBox {
-    pub fn create(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn create(&mut self, tx: Sender<ToolMessage>) -> Result<(), Box<dyn Error>> {
         let mut create_command = Command::new("distrobox");
         create_command
             .arg("create")
@@ -762,8 +896,39 @@ impl DistroBox {
                 .arg("--volume")
                 .arg(format!("{}:/{}:rw", volume, folder_name));
         }
-        create_command.status()?;
+        create_command.stdout(Stdio::piped());
+        create_command.stderr(Stdio::piped());
+        let mut child = create_command.spawn()?;
+        if let Some(stdout) = child.stdout.take() {
+            let tx_out = tx.clone();
+            std::thread::spawn(move || {
+                let reader = BufReader::new(stdout);
+                for line in reader.lines().flatten() {
+                    let _ = tx_out.send(ToolMessage::Output(line));
+                }
+            });
+        }
+        if let Some(stderr) = child.stderr.take() {
+            let tx_out = tx.clone();
+            std::thread::spawn(move || {
+                let reader = BufReader::new(stderr);
+                for line in reader.lines().flatten() {
+                    let _ = tx_out.send(ToolMessage::Output(line));
+                }
+            });
+        }
+        let status = child.wait()?;
+        if !status.success() {
+            let _ = tx.send(ToolMessage::Output(format!("error creating distrobox!")));
+        }
+
         self.created = true;
         return Ok(());
     }
 }
+
+struct Prompt {
+    action: Option<ToolMessage>,
+    responses: Vec<String>,
+    completed: bool,
+}