Method clean

src/linker.rs:1229–1395

Clean all symlinks managed by this configuration

(&self, options: &SyncOptions)

    /// Clean all symlinks managed by this configuration
    pub fn clean(&self, options: &SyncOptions) -> Result<SyncResult> {
        let mut result = SyncResult::default();

        println!("{}", "Cleaning managed symlinks...".cyan());

        for (agent_name, agent_config) in &self.config.agents {
            for target_config in agent_config.targets.values() {
                match target_config.sync_type {
                    SyncType::NestedGlob => {
                        // SECURITY: Validate destination template for traversal/absolute paths.
                        if self
                            .ensure_safe_destination(&target_config.destination)
                            .is_err()
                        {
                            continue;
                        }

                        // Re-discover the same files and remove the corresponding symlinks.
                        let search_root = self.project_root.join(&target_config.source);
                        // SECURITY: Validate search root to prevent traversal/absolute escapes.
                        if self.revalidate_path(&search_root).is_err() {
                            continue;
                        }
                        if !search_root.exists() || !search_root.is_dir() {
                            continue;
                        }
                        let glob_pattern =
                            target_config.pattern.as_deref().unwrap_or("**/AGENTS.md");
                        let dest_template = &target_config.destination;
                        let excludes = &target_config.exclude;

                        self.for_each_nested_glob_match(
                            &search_root,
                            glob_pattern,
                            excludes,
                            options,
                            |_, rel_path| {
                                let dest_str =
                                    Self::expand_destination_template(dest_template, rel_path);
                                if dest_str.is_empty() {
                                    return Ok(());
                                }

                                let dest = match self.ensure_safe_destination(&dest_str) {
                                    Ok(dest) => dest,
                                    Err(_) => return Ok(()),
                                };
                                if dest.is_symlink() {
                                    if options.dry_run {
                                        println!(
                                            "  {} Would remove: {}",
                                            "→".cyan(),
                                            dest.display()
                                        );
                                    } else {
                                        self.revalidate_unlink_path(&dest)?;
                                        fs::remove_file(&dest)?;
                                        self.invalidate_discovery_caches();