auditkit 0.1.0

package/src/ui.rs

@@ -0,0 +1,84 @@
+use std::time::Duration;
+
+use anyhow::Result;
+use colored::Colorize;
+use indicatif::{ProgressBar, ProgressStyle};
+
+pub fn section(title: &str) {
+    println!("\n{}", format!("== {title} ==").bold());
+}
+
+pub fn bullet(value: &str) {
+    println!("{} {value}", "-".cyan());
+}
+
+pub fn saved(path: impl std::fmt::Display) {
+    println!("{} {}", "[saved]".green(), path);
+}
+
+pub fn error(message: impl std::fmt::Display) {
+    eprintln!("{} {}", "[error]".red(), message);
+}
+
+pub fn score_status(score: i32) -> &'static str {
+    if score >= 85 {
+        "strong"
+    } else if score >= 65 {
+        "okay"
+    } else {
+        "needs work"
+    }
+}
+
+pub fn with_task<T>(label: &str, task: impl FnOnce() -> Result<T>) -> Result<T> {
+    let spinner = ProgressBar::new_spinner();
+    spinner.set_style(
+        ProgressStyle::with_template("{spinner:.cyan} {msg}")
+            .unwrap_or_else(|_| ProgressStyle::default_spinner()),
+    );
+    spinner.set_message(label.to_string());
+    spinner.enable_steady_tick(Duration::from_millis(80));
+
+    match task() {
+        Ok(value) => {
+            spinner.finish_with_message(format!("Done: {label}"));
+            Ok(value)
+        }
+        Err(error) => {
+            spinner.finish_with_message(format!("Failed: {label}"));
+            Err(error)
+        }
+    }
+}
+
+pub fn help() {
+    println!(
+        "{}",
+        "+--------------------------------------------------------+\n\
+| Audit Kit                                              |\n\
++--------------------------------------------------------+\n\
+| ak new              create audit workspace             |\n\
+| ak check latest     run + save quick website feedback  |\n\
+| ak security latest  run + save security header check   |\n\
+| ak lighthouse latest run + save Lighthouse audit       |\n\
+| ak inspect latest   run check + security + Lighthouse  |\n\
+| ak report latest    create final report + client email |\n\
+| ak list             show audit folders                 |\n\
+| ak check <url>      quick one-off website check        |\n\
+| ak security <url>   quick one-off security check       |\n\
+| ak lighthouse <url> quick one-off Lighthouse check     |\n\
++--------------------------------------------------------+"
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn score_status_matches_cli_labels() {
+        assert_eq!(score_status(95), "strong");
+        assert_eq!(score_status(74), "okay");
+        assert_eq!(score_status(40), "needs work");
+    }
+}

package/src/workspace.rs

@@ -0,0 +1,111 @@
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+
+use crate::audit::AuditInput;
+use crate::templates;
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    pub root: PathBuf,
+    pub audits_dir: PathBuf,
+}
+
+impl Workspace {
+    pub fn discover() -> Result<Self> {
+        let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        Ok(Self {
+            audits_dir: manifest_dir.join("audits"),
+            root: manifest_dir,
+        })
+    }
+
+    pub fn audit_folder(&self, folder_name: &str) -> PathBuf {
+        self.audits_dir.join(folder_name)
+    }
+
+    pub fn create_audit(&self, audit: &AuditInput) -> Result<PathBuf> {
+        let folder = self.audit_folder(&format!("{}-{}", audit.created_at, audit.slug));
+        fs::create_dir_all(&folder)?;
+
+        for (relative, content) in templates::create_audit_files(audit) {
+            let path = folder.join(relative);
+            if let Some(parent) = path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            fs::write(path, content)?;
+        }
+
+        Ok(folder)
+    }
+
+    pub fn list_audits(&self) -> Result<Vec<String>> {
+        fs::create_dir_all(&self.audits_dir)?;
+        let mut folders = Vec::new();
+
+        for entry in fs::read_dir(&self.audits_dir)? {
+            let entry = entry?;
+            if entry.file_type()?.is_dir() {
+                folders.push(entry.file_name().to_string_lossy().to_string());
+            }
+        }
+
+        folders.sort();
+        Ok(folders)
+    }
+
+    pub fn resolve_target(&self, target: Option<&str>) -> Result<String> {
+        let folders = self.list_audits()?;
+        if folders.is_empty() {
+            anyhow::bail!("No audits found.");
+        }
+
+        match target {
+            None | Some("latest") => Ok(folders.last().expect("non-empty").to_string()),
+            Some(value) if folders.iter().any(|folder| folder == value) => Ok(value.to_string()),
+            Some(value) => anyhow::bail!("Audit folder not found: {value}"),
+        }
+    }
+
+    pub fn read_audit_files(&self, folder_name: &str) -> Result<BTreeMap<String, String>> {
+        let folder = self.audit_folder(folder_name);
+        let mut files = BTreeMap::new();
+        read_markdown_files(&folder, &folder, &mut files)?;
+        Ok(files)
+    }
+
+    pub fn write_audit_file(
+        &self,
+        folder_name: &str,
+        filename: &str,
+        content: &str,
+    ) -> Result<PathBuf> {
+        let path = self.audit_folder(folder_name).join(filename);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::write(&path, content)?;
+        Ok(path)
+    }
+}
+
+fn read_markdown_files(
+    root: &Path,
+    current: &Path,
+    files: &mut BTreeMap<String, String>,
+) -> Result<()> {
+    for entry in fs::read_dir(current).with_context(|| format!("Reading {}", current.display()))? {
+        let entry = entry?;
+        let path = entry.path();
+        if entry.file_type()?.is_dir() {
+            read_markdown_files(root, &path, files)?;
+        } else if path.extension().is_some_and(|extension| extension == "md") {
+            let relative = path.strip_prefix(root)?.to_string_lossy().to_string();
+            files.insert(relative, fs::read_to_string(path)?);
+        }
+    }
+
+    Ok(())
+}