feat: add diecut extract command (engine-only)

src/cli.rs

@@ -49,4 +49,30 @@ pub enum Commands {
 
     /// List cached templates
     List,
+
+    /// Extract a template from an existing project
+    Extract {
+        /// Source project directory
+        source: String,
+
+        /// Variable values to templatize (can be repeated: --var key=value)
+        #[arg(long = "var", value_name = "KEY=VALUE")]
+        vars: Vec<String>,
+
+        /// Output directory for the extracted template
+        #[arg(short, long)]
+        output: Option<String>,
+
+        /// Convert the source directory in-place
+        #[arg(long)]
+        in_place: bool,
+
+        /// File with exclude patterns (one per line, # comments)
+        #[arg(long, value_name = "FILE")]
+        exclude_from: Option<String>,
+
+        /// Show what would be extracted without writing files
+        #[arg(long)]
+        dry_run: bool,
+    },
 }

src/commands/extract.rs

@@ -0,0 +1,93 @@
+use std::path::PathBuf;
+
+use console::style;
+
+use diecut::error::DicecutError;
+use diecut::extract::{execute_extraction, plan_extraction, ExtractOptions};
+use miette::Result;
+
+pub fn run(
+    source: String,
+    vars: Vec<String>,
+    output: Option<String>,
+    in_place: bool,
+    exclude_from: Option<String>,
+    dry_run: bool,
+) -> Result<()> {
+    let variables = parse_vars(&vars)?;
+
+    let options = ExtractOptions {
+        source_dir: PathBuf::from(&source),
+        variables,
+        output_dir: output.map(PathBuf::from),
+        in_place,
+        exclude_file: exclude_from.map(PathBuf::from),
+    };
+
+    let plan = plan_extraction(&options)?;
+
+    if dry_run {
+        print_dry_run(&plan);
+        return Ok(());
+    }
+
+    execute_extraction(&plan)?;
+
+    Ok(())
+}
+
+fn parse_vars(vars: &[String]) -> diecut::error::Result<Vec<(String, String)>> {
+    let mut parsed = Vec::new();
+
+    for var in vars {
+        let (key, value) = var
+            .split_once('=')
+            .ok_or_else(|| DicecutError::ExtractInvalidVar { input: var.clone() })?;
+        parsed.push((key.trim().to_string(), value.trim().to_string()));
+    }
+
+    Ok(parsed)
+}
+
+fn print_dry_run(plan: &diecut::extract::ExtractionPlan) {
+    eprintln!(
+        "\n{} Dry run — no files will be written\n",
+        style("⚡").yellow().bold()
+    );
+
+    eprintln!(
+        "Output directory: {}",
+        style(plan.output_dir.display()).cyan()
+    );
+
+    let templated: Vec<_> = plan.files.iter().filter(|f| f.has_replacements()).collect();
+    let copied: Vec<_> = plan
+        .files
+        .iter()
+        .filter(|f| !f.has_replacements())
+        .collect();
+
+    eprintln!("\nTemplated files ({}):", templated.len());
+    for file in &templated {
+        eprintln!(
+            "  {} ({} replacements)",
+            file.template_path.display(),
+            file.replacement_count()
+        );
+    }
+
+    eprintln!("\nCopied ({}):", copied.len());
+    for file in &copied {
+        eprintln!("  {}", file.template_path.display());
+    }
+
+    eprintln!("\nVariables:");
+    for var in &plan.variables {
+        eprintln!("  {} = {:?}", var.name, var.value);
+    }
+
+    eprintln!("\nGenerated diecut.toml:");
+    eprintln!("{}", style("─".repeat(60)).dim());
+    eprint!("{}", plan.config_toml);
+    eprintln!("{}", style("─".repeat(60)).dim());
+}

src/commands/mod.rs

@@ -1,2 +1,3 @@
+pub mod extract;
 pub mod list;
 pub mod new;

src/error.rs

@@ -117,6 +117,30 @@ pub enum DicecutError {
         #[source]
         source: toml::de::Error,
     },
+
+    #[error("Source directory not found: {path}")]
+    #[diagnostic(help("Provide the path to an existing project directory"))]
+    ExtractSourceNotFound { path: PathBuf },
+
+    #[error("No variables provided for extraction")]
+    #[diagnostic(help(
+        "Use --var key=value to specify variables, or ensure the project has identifiable names in config files or directory name"
+    ))]
+    ExtractNoVariables,
+
+    #[error("Invalid --var argument: {input} (expected key=value)")]
+    #[diagnostic(help("Use --var key=value format, e.g., --var project_name=my-app"))]
+    ExtractInvalidVar { input: String },
+
+    #[error("Output directory already exists: {path}")]
+    #[diagnostic(help(
+        "Choose a different output path with -o, or remove the existing directory"
+    ))]
+    ExtractOutputExists { path: PathBuf },
+
+    #[error("Directory already contains a diecut.toml: {path}")]
+    #[diagnostic(help("This directory is already a diecut template"))]
+    ExtractAlreadyTemplate { path: PathBuf },
 }
 
 pub type Result<T> = std::result::Result<T, DicecutError>;

src/extract/default_excludes.txt

@@ -0,0 +1,12 @@
+# Version control
+.git
+
+# Rust
+target
+Cargo.lock
+
+# macOS
+.DS_Store
+
+# Diecut
+.diecut-answers.toml

src/extract/exclude.rs

@@ -0,0 +1,82 @@
+use std::path::Path;
+
+const DEFAULT_EXCLUDES: &str = include_str!("default_excludes.txt");
+
+/// Load exclude patterns from a file, or use the built-in defaults.
+pub fn load_excludes(override_file: Option<&Path>) -> Vec<String> {
+    let text = match override_file {
+        Some(path) => {
+            std::fs::read_to_string(path).unwrap_or_else(|_| DEFAULT_EXCLUDES.to_string())
+        }
+        None => DEFAULT_EXCLUDES.to_string(),
+    };
+    text.lines()
+        .map(|l| l.trim())
+        .filter(|l| !l.is_empty() && !l.starts_with('#'))
+        .map(|l| l.to_string())
+        .collect()
+}
+
+/// Check if a path should be excluded based on the exclude patterns.
+pub fn should_exclude(relative_path: &Path, excludes: &[String]) -> bool {
+    let path_str = relative_path.to_string_lossy();
+
+    for pattern in excludes {
+        let clean = pattern.trim_end_matches('/');
+
+        if let Some(ext) = clean.strip_prefix("*.") {
+            if let Some(file_ext) = relative_path.extension() {
+                if file_ext.to_string_lossy().eq_ignore_ascii_case(ext) {
+                    return true;
+                }
+            }
+            continue;
+        }
+
+        for component in relative_path.components() {
+            if let std::path::Component::Normal(os_str) = component {
+                if os_str.to_string_lossy() == clean {
+                    return true;
+                }
+            }
+        }
+
+        if path_str == clean || path_str.starts_with(&format!("{clean}/")) {
+            return true;
+        }
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_load_defaults() {
+        let excludes = load_excludes(None);
+        assert!(excludes.contains(&".git".to_string()));
+        assert!(excludes.contains(&"target".to_string()));
+        assert!(excludes.contains(&".DS_Store".to_string()));
+        assert!(!excludes.iter().any(|e| e.starts_with('#')));
+    }
+
+    #[test]
+    fn test_should_exclude_matches() {
+        let excludes = vec![".git".to_string(), "*.pyc".to_string()];
+        assert!(should_exclude(Path::new(".git/HEAD"), &excludes));
+        assert!(should_exclude(Path::new("pkg/foo.pyc"), &excludes));
+        assert!(!should_exclude(Path::new("src/main.rs"), &excludes));
+    }
+
+    #[test]
+    fn test_override_file() {
+        let dir = tempfile::tempdir().unwrap();
+        let file = dir.path().join("excludes.txt");
+        std::fs::write(&file, "# custom\nvendor\n*.log\n").unwrap();
+
+        let excludes = load_excludes(Some(&file));
+        assert_eq!(excludes, vec!["vendor", "*.log"]);
+    }
+}