Method run

atomic-cli/src/commands/remove.rs:234–324

Execute the remove command. # Process 1. Find and open the repository 2. For each path: a. Remove from tracking b. If not --keep, delete from disk 3. Display results

(&self)

    ///    b. If not --keep, delete from disk
    /// 3. Display results
    fn run(&self) -> CliResult<()> {
        // Find repository
        let repo_root = find_repository_root()?;
        let repo = Repository::open(&repo_root).map_err(CliError::Repository)?;

        let options = self.to_tracking_options();
        let action = self.format_action();

        let mut total_removed = 0;
        let mut total_errors = 0;
        let mut files_to_delete: Vec<PathBuf> = Vec::new();

        // Process each path
        for path in &self.paths {
            // Normalize path relative to repo root
            let normalized = if std::path::Path::new(path).is_absolute() {
                match std::path::Path::new(path).strip_prefix(&repo_root) {
                    Ok(rel) => rel.to_string_lossy().to_string(),
                    Err(_) => {
                        print_warning(&format!("Path outside repository: {}", path));
                        total_errors += 1;
                        continue;
                    }
                }
            } else {
                path.clone()
            };

            if self.dry_run {
                println!("Would remove: {}", normalized);
            } else {
                println!("{}: {}", action, normalized);
            }

            // Remove from tracking
            match repo.remove(&normalized, options.clone()) {
                Ok(stats) => {
                    total_removed += stats.files_removed;

                    // Collect files to delete if not keeping
                    if self.delete && !self.keep && !self.dry_run {
                        files_to_delete.push(PathBuf::from(&normalized));
                    }
                }
                Err(e) => {
                    if !self.force {
                        print_warning(&format!("Failed to remove '{}': {}", normalized, e));
                        total_errors += 1;
                    }
                }
            }
        }

        // Delete files from disk if not keeping
        if !self.keep && !self.dry_run {
            for path in &files_to_delete {
                if let Err(e) = self.delete_file(&repo_root, &path.to_string_lossy()) {
                    print_warning(&format!("Failed to delete '{}': {}", path.display(), e));