Method process_module_map

src/linker.rs:1123–1178

Process a `module-map` target: iterate mappings and create a symlink for each one, resolving the destination filename from: 1. mapping.filename_override (explicit user choice) 2. agent_convention_filename (per-agent convention) 3. source file basename (fallback)

(
        &self,
        agent_name: &str,
        target: &TargetConfig,
        options: &SyncOptions,
    )

    /// 2. agent_convention_filename (per-agent convention)
    /// 3. source file basename (fallback)
    fn process_module_map(
        &self,
        agent_name: &str,
        target: &TargetConfig,
        options: &SyncOptions,
    ) -> Result<SyncResult> {
        let mut result = SyncResult::default();

        if target.mappings.is_empty() {
            if options.verbose {
                println!(
                    "  {} No mappings defined for module-map target",
                    "!".yellow()
                );
            }
            return Ok(result);
        }

        for mapping in &target.mappings {
            let source_path = self.source_dir.join(&mapping.source);
            self.revalidate_path(&source_path)?; // SECURITY: Validate source

            // Resolve destination filename
            let filename = crate::config::resolve_module_map_filename(mapping, agent_name);

            // SECURITY: Validate that the joined destination (dir + filename) is safe.
            let dest_str = format!("{}/{}", mapping.destination, filename);
            let dest = match self.ensure_safe_destination(&dest_str) {
                Ok(d) => d,
                Err(e) => {
                    if options.verbose {
                        println!(
                            "  {} Skipping mapping {}: {}",
                            "!".yellow(),
                            mapping.source,
                            e
                        );
                    }
                    result.skipped += 1;
                    continue;
                }
            };

            let resolved = ResolvedSource {
                path: source_path.clone(),
                exists: source_path.exists(),
            };

            let item_result = self.create_symlink(&resolved, &dest, options)?;
            result.created += item_result.created;
            result.updated += item_result.updated;
            result.skipped += item_result.skipped;
        }

        Ok(result)
    }

    /// Get the canonical path for a given path, using a cache to avoid