feat: implement devtrail new command for document creation

Replaces devtrail-new.sh (267 lines) with native CLI command.
Supports interactive mode (dialoguer) and non-interactive via
--doc-type/-t and --title flags. Adds DocType helpers: directory(),
display_name(), from_str_loose(), ALL constant. Includes 4
integration tests and 6 unit tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: montfort

cli/src/commands/mod.rs

@@ -7,6 +7,7 @@ pub mod compliance;
 pub mod explore;
 pub mod init;
 pub mod metrics;
+pub mod new;
 pub mod remove;
 pub mod repair;
 pub mod status;

cli/src/commands/new.rs

@@ -0,0 +1,227 @@
+use anyhow::{bail, Context, Result};
+use chrono::Local;
+use colored::Colorize;
+use dialoguer::{theme::ColorfulTheme, Input, Select};
+use std::path::PathBuf;
+
+use crate::config::DevTrailConfig;
+use crate::document::DocType;
+use crate::utils;
+
+pub fn run(path: &str, doc_type_arg: Option<&str>, title_arg: Option<&str>) -> Result<()> {
+    let resolved = utils::resolve_project_root(path)
+        .ok_or_else(|| anyhow::anyhow!("DevTrail not installed. Run 'devtrail init' first."))?;
+    let target = resolved.path;
+    let devtrail_dir = target.join(".devtrail");
+
+    let config = DevTrailConfig::load(&target).unwrap_or_default();
+    let lang = &config.language;
+
+    // Select document type
+    let doc_type = match doc_type_arg {
+        Some(t) => DocType::from_str_loose(t).ok_or_else(|| {
+            anyhow::anyhow!(
+                "Unknown document type '{}'. Valid types: {}",
+                t,
+                DocType::ALL
+                    .iter()
+                    .map(|d| d.prefix().to_lowercase())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        })?,
+        None => select_type_interactive()?,
+    };
+
+    // Get title
+    let title = match title_arg {
+        Some(t) => t.to_string(),
+        None => Input::with_theme(&ColorfulTheme::default())
+            .with_prompt("Title")
+            .interact_text()?,
+    };
+    if title.trim().is_empty() {
+        bail!("Title is required");
+    }
+
+    // Generate slug, date, sequence
+    let slug = slugify(&title);
+    let today = Local::now().format("%Y-%m-%d").to_string();
+    let doc_dir = devtrail_dir.join(doc_type.directory());
+    let seq = next_sequence_number(&doc_dir, doc_type, &today);
+
+    // Load and fill template
+    let template_path = resolve_template_path(&devtrail_dir, doc_type, lang);
+    let template = std::fs::read_to_string(&template_path)
+        .with_context(|| format!("Template not found: {}", template_path.display()))?;
+
+    let id = format!("{}-{}-{}", doc_type.prefix(), today, seq);
+    let content = template
+        .replace("YYYY-MM-DD-NNN", &format!("{}-{}", today, seq))
+        .replace("YYYY-MM-DD", &today)
+        .replace("[Descriptive title of the action]", &title)
+        .replace("[Título descriptivo de la acción]", &title)
+        .replace("[Decision title]", &title)
+        .replace("[Título de la decisión]", &title)
+        .replace("[Architectural decision title]", &title)
+        .replace("[Título de la decisión arquitectónica]", &title)
+        .replace("[Assessment title]", &title)
+        .replace("[Título de la evaluación]", &title)
+        .replace("[Model/System name]", &title)
+        .replace("[Nombre del modelo/sistema]", &title)
+        .replace("[System name]", &title)
+        .replace("[Nombre del sistema]", &title)
+        .replace("[Assessment scope]", &title)
+        .replace("[Alcance de la evaluación]", &title)
+        .replace("[Title]", &title)
+        .replace("[Título]", &title)
+        .replace("[agent-name-v1.0]", "manual-user")
+        .replace("[nombre-agente-v1.0]", "manual-user")
+        .replace("id: AILOG-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: AIDEC-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: ADR-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: ETH-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: REQ-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: TES-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: INC-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: TDE-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: SEC-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: MCARD-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: SBOM-YYYY-MM-DD-NNN", &format!("id: {}", id))
+        .replace("id: DPIA-YYYY-MM-DD-NNN", &format!("id: {}", id));
+
+    // Write file
+    let filename = format!("{}-{}-{}-{}.md", doc_type.prefix(), today, seq, slug);
+    utils::ensure_dir(&doc_dir)?;
+    let filepath = doc_dir.join(&filename);
+    std::fs::write(&filepath, content)?;
+
+    // Print result
+    let rel_path = filepath
+        .strip_prefix(&target)
+        .unwrap_or(&filepath)
+        .display();
+    println!();
+    utils::success(&format!("Created: {}", rel_path));
+    println!();
+    println!("  {}", "Next steps:".bold());
+    println!("    1. Edit the document to fill in details");
+    println!(
+        "    2. Commit: {}",
+        format!("git add {}", rel_path).dimmed()
+    );
+    println!();
+
+    Ok(())
+}
+
+fn select_type_interactive() -> Result<DocType> {
+    let items: Vec<String> = DocType::ALL
+        .iter()
+        .map(|t| format!("{:<6} — {}", t.prefix().to_lowercase(), t.display_name()))
+        .collect();
+
+    let selection = Select::with_theme(&ColorfulTheme::default())
+        .with_prompt("Document type")
+        .items(&items)
+        .default(0)
+        .interact()?;
+
+    Ok(DocType::ALL[selection])
+}
+
+fn slugify(title: &str) -> String {
+    let lower = title.to_lowercase();
+    let parts: Vec<&str> = lower
+        .split(|c: char| !c.is_ascii_alphanumeric())
+        .filter(|s| !s.is_empty())
+        .collect();
+    let slug = parts.join("-");
+    if slug.len() > 50 {
+        slug[..50].trim_end_matches('-').to_string()
+    } else {
+        slug
+    }
+}
+
+fn next_sequence_number(doc_dir: &std::path::Path, doc_type: DocType, today: &str) -> String {
+    let prefix_pattern = format!("{}-{}-", doc_type.prefix(), today);
+    let mut max_seq = 0u32;
+
+    if doc_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(doc_dir) {
+            for entry in entries.flatten() {
+                let name = entry.file_name();
+                let name = name.to_str().unwrap_or("");
+                if let Some(rest) = name.strip_prefix(&prefix_pattern) {
+                    if rest.len() >= 3 {
+                        if let Ok(n) = rest[..3].parse::<u32>() {
+                            max_seq = max_seq.max(n);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    format!("{:03}", max_seq + 1)
+}
+
+fn resolve_template_path(
+    devtrail_dir: &std::path::Path,
+    doc_type: DocType,
+    lang: &str,
+) -> PathBuf {
+    let template_name = format!("TEMPLATE-{}.md", doc_type.prefix());
+    if lang == "es" {
+        let es_path = devtrail_dir
+            .join("templates/i18n/es")
+            .join(&template_name);
+        if es_path.exists() {
+            return es_path;
+        }
+    }
+    devtrail_dir.join("templates").join(&template_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_slugify() {
+        assert_eq!(slugify("Hello World"), "hello-world");
+        assert_eq!(slugify("Fix: auth bug #123"), "fix-auth-bug-123");
+        assert_eq!(slugify("  spaces  everywhere  "), "spaces-everywhere");
+        assert_eq!(slugify("UPPER-case_mixed"), "upper-case-mixed");
+    }
+
+    #[test]
+    fn test_slugify_truncates() {
+        let long_title = "a".repeat(60);
+        assert!(slugify(&long_title).len() <= 50);
+    }
+
+    #[test]
+    fn test_next_sequence_empty_dir() {
+        let dir = tempfile::TempDir::new().unwrap();
+        assert_eq!(
+            next_sequence_number(dir.path(), DocType::Ailog, "2026-04-01"),
+            "001"
+        );
+    }
+
+    #[test]
+    fn test_next_sequence_increments() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("AILOG-2026-04-01-001-first.md"),
+            "test",
+        )
+        .unwrap();
+        assert_eq!(
+            next_sequence_number(dir.path(), DocType::Ailog, "2026-04-01"),
+            "002"
+        );
+    }
+}

cli/tests/new_test.rs

@@ -0,0 +1,132 @@
+use assert_cmd::Command;
+use predicates::prelude::*;
+use tempfile::TempDir;
+
+/// Set up a minimal DevTrail installation with a template for the given type
+fn setup_devtrail_with_template(dir: &std::path::Path, doc_type: &str) {
+    let devtrail = dir.join(".devtrail");
+    std::fs::create_dir_all(devtrail.join("templates")).unwrap();
+    std::fs::write(
+        devtrail.join("config.yml"),
+        "language: en\n",
+    )
+    .unwrap();
+
+    let template_name = format!("TEMPLATE-{}.md", doc_type.to_uppercase());
+    let template_content = format!(
+        "---\nid: {}-YYYY-MM-DD-NNN\ntitle: \"[Title]\"\nstatus: draft\ncreated: YYYY-MM-DD\nagent: \"[agent-name-v1.0]\"\nconfidence: medium\nreview_required: false\nrisk_level: low\n---\n\n# [Title]\n",
+        doc_type.to_uppercase()
+    );
+    std::fs::write(
+        devtrail.join("templates").join(&template_name),
+        template_content,
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_new_requires_devtrail_installed() {
+    let dir = TempDir::new().unwrap();
+
+    let mut cmd = Command::cargo_bin("devtrail").unwrap();
+    cmd.arg("new")
+        .arg("--doc-type")
+        .arg("ailog")
+        .arg("--title")
+        .arg("Test")
+        .arg(dir.path().to_str().unwrap())
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("not installed"));
+}
+
+#[test]
+fn test_new_with_type_and_title_args() {
+    let dir = TempDir::new().unwrap();
+    setup_devtrail_with_template(dir.path(), "AILOG");
+
+    let mut cmd = Command::cargo_bin("devtrail").unwrap();
+    cmd.arg("new")
+        .arg("--doc-type")
+        .arg("ailog")
+        .arg("--title")
+        .arg("Test Document")
+        .arg(dir.path().to_str().unwrap())
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Created:"));
+
+    // Verify file was created in the correct directory
+    let agent_logs_dir = dir.path().join(".devtrail/07-ai-audit/agent-logs");
+    assert!(agent_logs_dir.exists(), "agent-logs directory should exist");
+
+    let entries: Vec<_> = std::fs::read_dir(&agent_logs_dir)
+        .unwrap()
+        .flatten()
+        .collect();
+    assert_eq!(entries.len(), 1, "should have exactly one file");
+
+    let filename = entries[0].file_name();
+    let filename = filename.to_str().unwrap();
+    assert!(filename.starts_with("AILOG-"), "filename should start with AILOG-");
+    assert!(filename.ends_with("-test-document.md"), "filename should end with slug");
+    assert!(filename.contains("-001-"), "filename should contain sequence 001");
+}
+
+#[test]
+fn test_new_sequence_increments() {
+    let dir = TempDir::new().unwrap();
+    setup_devtrail_with_template(dir.path(), "AILOG");
+
+    // Create first document
+    Command::cargo_bin("devtrail")
+        .unwrap()
+        .arg("new")
+        .arg("--doc-type")
+        .arg("ailog")
+        .arg("--title")
+        .arg("First")
+        .arg(dir.path().to_str().unwrap())
+        .assert()
+        .success();
+
+    // Create second document
+    Command::cargo_bin("devtrail")
+        .unwrap()
+        .arg("new")
+        .arg("--doc-type")
+        .arg("ailog")
+        .arg("--title")
+        .arg("Second")
+        .arg(dir.path().to_str().unwrap())
+        .assert()
+        .success();
+
+    let agent_logs_dir = dir.path().join(".devtrail/07-ai-audit/agent-logs");
+    let entries: Vec<String> = std::fs::read_dir(&agent_logs_dir)
+        .unwrap()
+        .flatten()
+        .map(|e| e.file_name().to_str().unwrap().to_string())
+        .collect();
+
+    assert_eq!(entries.len(), 2);
+    assert!(entries.iter().any(|f| f.contains("-001-")), "should have seq 001");
+    assert!(entries.iter().any(|f| f.contains("-002-")), "should have seq 002");
+}
+
+#[test]
+fn test_new_unknown_type() {
+    let dir = TempDir::new().unwrap();
+    setup_devtrail_with_template(dir.path(), "AILOG");
+
+    let mut cmd = Command::cargo_bin("devtrail").unwrap();
+    cmd.arg("new")
+        .arg("--doc-type")
+        .arg("invalid")
+        .arg("--title")
+        .arg("Test")
+        .arg(dir.path().to_str().unwrap())
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("Unknown document type"));
+}