archive cmd

Author: wcygan

Cargo.lock

@@ -17,6 +17,7 @@ dirs = "5.0"
 regex = "1.10"
 reqwest = { version = "0.12", features = ["rustls-tls"], default-features = false }
 tokio = { version = "1.43", features = ["rt-multi-thread", "macros", "process", "io-util", "fs", "signal"] }
+chrono = "0.4"
 
 [dev-dependencies]
 assert_cmd = "2.1.2"

Cargo.toml

@@ -15,6 +15,15 @@ pub const LOG_FILE: &str = "ralph.log";
 /// All ralph files that can be created/cleaned.
 pub const RALPH_FILES: &[&str] = &[SPEC_FILE, IMPLEMENTATION_PLAN_FILE, PROMPT_FILE, LOG_FILE];
 
+/// Files that are archived (stateful files, not templates or logs).
+pub const ARCHIVABLE_FILES: &[&str] = &[SPEC_FILE, IMPLEMENTATION_PLAN_FILE];
+
+/// The ralphctl directory for storing archives and other data.
+pub const RALPHCTL_DIR: &str = ".ralphctl";
+
+/// The archive subdirectory within .ralphctl.
+pub const ARCHIVE_DIR: &str = "archive";
+
 /// Find all ralph files that exist in the given directory.
 ///
 /// Returns a list of paths to existing ralph files.
@@ -31,6 +40,22 @@ pub fn any_ralph_files_exist(dir: &Path) -> bool {
     RALPH_FILES.iter().any(|name| dir.join(name).exists())
 }
 
+/// Find archivable files that exist in the given directory.
+///
+/// Returns a list of paths to existing archivable files.
+pub fn find_archivable_files(dir: &Path) -> Vec<PathBuf> {
+    ARCHIVABLE_FILES
+        .iter()
+        .map(|name| dir.join(name))
+        .filter(|path| path.exists())
+        .collect()
+}
+
+/// Get the base archive directory path (.ralphctl/archive).
+pub fn archive_base_dir(dir: &Path) -> PathBuf {
+    dir.join(RALPHCTL_DIR).join(ARCHIVE_DIR)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -97,4 +122,46 @@ mod tests {
         assert!(RALPH_FILES.contains(&LOG_FILE));
         assert_eq!(RALPH_FILES.len(), 4);
     }
+
+    #[test]
+    fn test_archivable_files_constant() {
+        assert!(ARCHIVABLE_FILES.contains(&SPEC_FILE));
+        assert!(ARCHIVABLE_FILES.contains(&IMPLEMENTATION_PLAN_FILE));
+        assert_eq!(ARCHIVABLE_FILES.len(), 2);
+        // PROMPT.md and ralph.log are NOT archivable
+        assert!(!ARCHIVABLE_FILES.contains(&PROMPT_FILE));
+        assert!(!ARCHIVABLE_FILES.contains(&LOG_FILE));
+    }
+
+    #[test]
+    fn test_find_archivable_files_empty() {
+        let dir = create_temp_dir();
+        let found = find_archivable_files(dir.path());
+        assert!(found.is_empty());
+    }
+
+    #[test]
+    fn test_find_archivable_files_only_archivable() {
+        let dir = create_temp_dir();
+
+        // Create archivable files
+        fs::write(dir.path().join(SPEC_FILE), "# Spec").unwrap();
+        fs::write(dir.path().join(IMPLEMENTATION_PLAN_FILE), "# Plan").unwrap();
+        // Create non-archivable file
+        fs::write(dir.path().join(PROMPT_FILE), "# Prompt").unwrap();
+
+        let found = find_archivable_files(dir.path());
+        assert_eq!(found.len(), 2);
+        assert!(found.iter().any(|p| p.ends_with(SPEC_FILE)));
+        assert!(found.iter().any(|p| p.ends_with(IMPLEMENTATION_PLAN_FILE)));
+        // PROMPT.md should not be in the list
+        assert!(!found.iter().any(|p| p.ends_with(PROMPT_FILE)));
+    }
+
+    #[test]
+    fn test_archive_base_dir() {
+        let dir = create_temp_dir();
+        let archive_dir = archive_base_dir(dir.path());
+        assert!(archive_dir.ends_with(".ralphctl/archive"));
+    }
 }

src/files.rs

@@ -67,6 +67,13 @@ enum Command {
         #[arg(long)]
         force: bool,
     },
+
+    /// Archive current SPEC.md and IMPLEMENTATION_PLAN.md, then reset to blank
+    Archive {
+        /// Skip confirmation prompt
+        #[arg(long)]
+        force: bool,
+    },
 }
 
 #[tokio::main]
@@ -93,6 +100,9 @@ async fn main() -> Result<()> {
         Command::Clean { force } => {
             clean_cmd(force)?;
         }
+        Command::Archive { force } => {
+            archive_cmd(force)?;
+        }
     }
 
     Ok(())
@@ -149,6 +159,105 @@ fn clean_cmd(force: bool) -> Result<()> {
     Ok(())
 }
 
+fn archive_cmd(force: bool) -> Result<()> {
+    let cwd = Path::new(".");
+    let archivable_files = files::find_archivable_files(cwd);
+
+    if archivable_files.is_empty() {
+        println!("No archivable files found.");
+        return Ok(());
+    }
+
+    let file_count = archivable_files.len();
+
+    if !force {
+        eprint!(
+            "Archive {} file{}? [y/N] ",
+            file_count,
+            if file_count == 1 { "" } else { "s" }
+        );
+        io::stderr().flush()?;
+
+        let mut input = String::new();
+        io::stdin().read_line(&mut input)?;
+
+        let answer = input.trim().to_lowercase();
+        if answer != "y" && answer != "yes" {
+            std::process::exit(error::exit::ERROR);
+        }
+    }
+
+    // Ensure .ralphctl is in .gitignore
+    update_gitignore(cwd)?;
+
+    // Create timestamped archive directory
+    let timestamp = generate_timestamp();
+    let archive_dir = files::archive_base_dir(cwd).join(&timestamp);
+    fs::create_dir_all(&archive_dir)?;
+
+    // Copy files to archive
+    for path in &archivable_files {
+        let filename = path.file_name().unwrap();
+        let dest = archive_dir.join(filename);
+        fs::copy(path, dest)?;
+    }
+
+    // Reset original files to blank templates
+    for path in &archivable_files {
+        let blank = generate_blank_content(path);
+        fs::write(path, blank)?;
+    }
+
+    println!(
+        "Archived {} file{} to {}",
+        file_count,
+        if file_count == 1 { "" } else { "s" },
+        archive_dir.display()
+    );
+
+    Ok(())
+}
+
+/// Generate a filesystem-safe timestamp for archive directories.
+fn generate_timestamp() -> String {
+    chrono::Local::now().format("%Y-%m-%dT%H-%M-%S").to_string()
+}
+
+/// Generate blank content for a given file.
+fn generate_blank_content(path: &Path) -> &'static str {
+    let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+    match filename {
+        files::SPEC_FILE => "# Specification\n\n",
+        files::IMPLEMENTATION_PLAN_FILE => "# Implementation Plan\n\n",
+        _ => "",
+    }
+}
+
+/// Update .gitignore to include .ralphctl if not already present.
+fn update_gitignore(dir: &Path) -> Result<()> {
+    let gitignore_path = dir.join(".gitignore");
+    let entry = files::RALPHCTL_DIR;
+
+    if gitignore_path.exists() {
+        let content = fs::read_to_string(&gitignore_path)?;
+        // Check if entry already exists (as a complete line)
+        if content.lines().any(|line| line.trim() == entry) {
+            return Ok(());
+        }
+        // Append entry with newline handling
+        let suffix = if content.ends_with('\n') || content.is_empty() {
+            format!("{}\n", entry)
+        } else {
+            format!("\n{}\n", entry)
+        };
+        fs::write(&gitignore_path, content + &suffix)?;
+    } else {
+        fs::write(&gitignore_path, format!("{}\n", entry))?;
+    }
+
+    Ok(())
+}
+
 fn run_cmd(max_iterations: u32, pause: bool, model: Option<&str>) -> Result<()> {
     // Step 1: Validate required files exist
     run::validate_required_files()?;
@@ -351,14 +460,11 @@ NEVER use paths from other context (like ~/.claude/CLAUDE.md). The path above is
         cmd.arg("--model").arg(m);
     }
 
-    let status = cmd
-        .arg(INITIAL_PROMPT)
-        .status()
-        .inspect_err(|e| {
-            if e.kind() == std::io::ErrorKind::NotFound {
-                error::die("claude not found in PATH");
-            }
-        })?;
+    let status = cmd.arg(INITIAL_PROMPT).status().inspect_err(|e| {
+        if e.kind() == std::io::ErrorKind::NotFound {
+            error::die("claude not found in PATH");
+        }
+    })?;
 
     if !status.success() {
         error::die(&format!(