Merge branch 'main' into docs/update-readme-accuracy-2960652682020426675

Author: yacosta738

.agents/journal/bolt.md

@@ -23,3 +23,14 @@
 **Learning:** The `compress_agents_md_content` function was performing $O(N)$ string allocations, where $N$ is the number of lines in `AGENTS.md`. By refactoring helper functions to use mutable buffer passing and switching code fence state to use string slices (`&str`), we eliminated almost all heap allocations in the compression loop.
 
 **Action:** Avoid returning `String` from functions called inside loops processing large text files. Instead, pass a mutable `&mut String` buffer to be filled. Use `Option<&str>` instead of `Option<String>` for state that refers to parts of the input buffer.
+
+## 2026-02-15 - Caching Redundant I/O and Compression
+
+**Learning:** Multiple agents often share the same source file (e.g., AGENTS.md) or target directories. Without caching, the Linker performs redundant file reads, string compression, and directory existence checks for every target.
+**Action:** Implement `compression_cache` (HashMap) to memoize expensive text compression and `ensured_outputs` (HashSet) to track verified destination paths. This optimization reduced execution time by ~83% (from 0.055s to 0.0094s) in a 100-agent scenario.
+
+## 2026-02-26 - Support for 34 New Agents and Config Migration
+
+**Learning:** Supporting a wide array of AI agents (41 total) requires handling diverse MCP configuration formats (YAML, nested JSON) and legacy instruction files (e.g., ROO.md, CLINE.md). Centralizing these into a unified structure during 'init --wizard' and using specialized formatters (Standard, YAML, Continue) ensures a seamless developer experience across all tools.
+
+**Action:** When adding support for new agents, identify their specific configuration requirements (path, format, and instruction file naming) and implement reusable formatters. Always prioritize automated migration of existing configuration to the central .agents/ directory to minimize manual setup.

.gitignore

@@ -35,12 +35,18 @@ node_modules/
 .pnpm-store/
 pnpm-debug.log
 # START AI Agent Symlinks
+.claude/commands/
+.claude/skills/
 .github/agents
 .github/copilot-instructions.md
 .github/prompts
 .github/skills
+.mcp.json
 .opencode/command
 .opencode/skill
+.vscode/mcp.json
 AGENTS.md
 CLAUDE.md
+opencode.json
 # END AI Agent Symlinks
+changes.diff

fix_clippy.py

@@ -0,0 +1,69 @@
+import sys
+
+with open('src/fs.rs', 'r') as f:
+    fs_content = f.read()
+
+old_fs = """        if let Some(parent) = dst_abs.parent() {
+            if let Ok(parent_canon) = fs::canonicalize(parent) {
+                if parent_canon.starts_with(&src_canon) {
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::InvalidInput,
+                        format!("Cannot copy directory into itself: {:?} is inside {:?}", dst_abs, src_canon),
+                    ).into());
+                }
+            }
+        }"""
+
+new_fs = """        if let Some(parent_canon) = dst_abs.parent().and_then(|p| fs::canonicalize(p).ok()) {
+            if parent_canon.starts_with(&src_canon) {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    format!("Cannot copy directory into itself: {:?} is inside {:?}", dst_abs, src_canon),
+                ).into());
+            }
+        }"""
+
+fs_content = fs_content.replace(old_fs, new_fs)
+with open('src/fs.rs', 'w') as f:
+    f.write(fs_content)
+
+with open('src/mcp.rs', 'r') as f:
+    mcp_content = f.read()
+
+old_mcp1 = """        if let Some(key) = self.wrapper_key {
+            if let Some(wrapped) = parsed.get(key) {
+                if let Some(obj) = wrapped.as_mapping() {
+                   let mut res = HashMap::new();
+                   for (k, v) in obj {
+                       let key_str = k.as_str().unwrap_or_default().to_string();
+                       let json_v = serde_json::to_value(v)?;
+                       res.insert(key_str, json_v);
+                   }
+                   return Ok(res);
+                }
+            }
+        }"""
+
+new_mcp1 = """        if let Some(obj) = self.wrapper_key.and_then(|key| parsed.get(key)).and_then(|v| v.as_mapping()) {
+            let mut res = HashMap::new();
+            for (k, v) in obj {
+                let key_str = k.as_str().unwrap_or_default().to_string();
+                let json_v = serde_json::to_value(v)?;
+                res.insert(key_str, json_v);
+            }
+            return Ok(res);
+        }"""
+
+old_mcp2 = """        if let Some(mcp) = parsed.get("mcpServers") {
+            if let Some(obj) = mcp.as_object() {
+                return Ok(obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect());
+            }
+        }"""
+
+new_mcp2 = """        if let Some(obj) = parsed.get("mcpServers").and_then(|mcp| mcp.as_object()) {
+            return Ok(obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect());
+        }"""
+
+mcp_content = mcp_content.replace(old_mcp1, new_mcp1).replace(old_mcp2, new_mcp2)
+with open('src/mcp.rs', 'w') as f:
+    f.write(mcp_content)

fix_clippy_v2.py

@@ -0,0 +1,63 @@
+import sys
+
+with open('src/mcp.rs', 'r') as f:
+    mcp_content = f.read()
+
+# Fix YAML parse_existing
+old_yaml_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: serde_yaml::Value = serde_yaml::from_str(content).context("Failed to parse YAML")?;
+        if let Some(key) = self.wrapper_key {
+            if let Some(wrapped) = parsed.get(key) {
+                if let Some(obj) = wrapped.as_mapping() {
+                   let mut res = HashMap::new();
+                   for (k, v) in obj {
+                       let key_str = k.as_str().unwrap_or_default().to_string();
+                       let json_v = serde_json::to_value(v)?;
+                       res.insert(key_str, json_v);
+                   }
+                   return Ok(res);
+                }
+            }
+        }
+        Ok(HashMap::new())
+    }"""
+
+new_yaml_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: serde_yaml::Value = serde_yaml::from_str(content).context("Failed to parse YAML")?;
+        if let Some(obj) = self.wrapper_key
+            .and_then(|key| parsed.get(key))
+            .and_then(|v| v.as_mapping())
+        {
+            let mut res = HashMap::new();
+            for (k, v) in obj {
+                let key_str = k.as_str().unwrap_or_default().to_string();
+                let json_v = serde_json::to_value(v)?;
+                res.insert(key_str, json_v);
+            }
+            return Ok(res);
+        }
+        Ok(HashMap::new())
+    }"""
+
+# Fix Continue parse_existing
+old_continue_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: Value = serde_json::from_str(content).unwrap_or(json!({}));
+        if let Some(mcp) = parsed.get("mcpServers") {
+            if let Some(obj) = mcp.as_object() {
+                return Ok(obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect());
+            }
+        }
+        Ok(HashMap::new())
+    }"""
+
+new_continue_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: Value = serde_json::from_str(content).unwrap_or(json!({}));
+        if let Some(obj) = parsed.get("mcpServers").and_then(|mcp| mcp.as_object()) {
+            return Ok(obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect());
+        }
+        Ok(HashMap::new())
+    }"""
+
+mcp_content = mcp_content.replace(old_yaml_parse, new_yaml_parse).replace(old_continue_parse, new_continue_parse)
+with open('src/mcp.rs', 'w') as f:
+    f.write(mcp_content)

fix_clippy_v3.py

@@ -0,0 +1,67 @@
+import sys
+
+with open('src/fs.rs', 'r') as f:
+    fs_content = f.read()
+
+old_fs = """        if let Some(parent_canon) = dst_abs
+            .parent()
+            .and_then(|p| fs::canonicalize(p).ok())
+            .filter(|p| p.starts_with(&src_canon))
+        {"""
+
+new_fs = """        if dst_abs
+            .parent()
+            .and_then(|p| fs::canonicalize(p).ok())
+            .filter(|p| p.starts_with(&src_canon))
+            .is_some()
+        {"""
+
+fs_content = fs_content.replace(old_fs, new_fs)
+with open('src/fs.rs', 'w') as f:
+    f.write(fs_content)
+
+with open('src/mcp.rs', 'r') as f:
+    mcp_content = f.read()
+
+# Fix YAML parse_existing (nested ifs)
+old_yaml_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: serde_yaml::Value = serde_yaml::from_str(content).context("Failed to parse YAML")?;
+        if let Some(obj) = self.wrapper_key
+            .and_then(|key| parsed.get(key))
+            .and_then(|v| v.as_mapping())
+        {
+            let mut res = HashMap::new();
+            for (k, v) in obj {
+                let key_str = k.as_str().unwrap_or_default().to_string();
+                let json_v = serde_json::to_value(v)?;
+                res.insert(key_str, json_v);
+            }
+            return Ok(res);
+        }
+        Ok(HashMap::new())
+    }"""
+
+# Wait, I previously used python script to fix clippy, let me re-read it.
+# Actually I'll just write it correctly.
+new_yaml_parse = """    fn parse_existing(&self, content: &str) -> Result<HashMap<String, Value>> {
+        let parsed: serde_yaml::Value =
+            serde_yaml::from_str(content).context("Failed to parse YAML")?;
+        if let Some(obj) = self
+            .wrapper_key
+            .and_then(|key| parsed.get(key))
+            .and_then(|v| v.as_mapping())
+        {
+            let mut res = HashMap::new();
+            for (k, v) in obj {
+                let key_str = k.as_str().unwrap_or_default().to_string();
+                let json_v = serde_json::to_value(v)?;
+                res.insert(key_str, json_v);
+            }
+            return Ok(res);
+        }
+        Ok(HashMap::new())
+    }"""
+
+# Actually the error was: this  statement can be collapsed
+# but I already used .and_then chain. Clippy might still complain if I have if let inside if let.
+# Let's check the code.

npm/agentsync/package.json

@@ -1,61 +1,61 @@
 {
-  "name": "@dallay/agentsync",
-  "version": "1.28.0",
-  "description": "A fast CLI tool to sync AI agent configurations and MCP servers across Claude, Copilot, Cursor, and more using symbolic links.",
-  "author": "Yuniel Acosta <yunielacosta738@gmail.com>",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dallay/agentsync.git"
-  },
-  "homepage": "https://github.com/dallay/agentsync#readme",
-  "bugs": {
-    "url": "https://github.com/dallay/agentsync/issues"
-  },
-  "keywords": [
-    "ai",
-    "agents",
-    "symlink",
-    "configuration",
-    "cli",
-    "claude",
-    "copilot",
-    "gemini",
-    "cursor",
-    "opencode",
-    "mcp",
-    "mcp-server"
-  ],
-  "bin": {
-    "agentsync": "lib/index.js"
-  },
-  "main": "lib/index.js",
-  "files": [
-    "lib"
-  ],
-  "scripts": {
-    "test": "pnpm run typecheck",
-    "typecheck": "tsc --noEmit",
-    "build": "tsc",
-    "clean": "node -e \"require('fs').rmSync('lib', {recursive: true, force: true})\"",
-    "prepublishOnly": "npm run build"
-  },
-  "devDependencies": {
-    "@types/node": "^24.1.0",
-    "typescript": "^5.9.3"
-  },
-  "optionalDependencies": {
-    "@dallay/agentsync-linux-x64": "1.28.0",
-    "@dallay/agentsync-linux-arm64": "1.28.0",
-    "@dallay/agentsync-darwin-x64": "1.28.0",
-    "@dallay/agentsync-darwin-arm64": "1.28.0",
-    "@dallay/agentsync-windows-x64": "1.28.0",
-    "@dallay/agentsync-windows-arm64": "1.28.0"
-  },
-  "engines": {
-    "node": ">=18"
-  }
+	"name": "@dallay/agentsync",
+	"version": "1.28.0",
+	"description": "A fast CLI tool to sync AI agent configurations and MCP servers across Claude, Copilot, Cursor, and more using symbolic links.",
+	"author": "Yuniel Acosta <yunielacosta738@gmail.com>",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/dallay/agentsync.git"
+	},
+	"homepage": "https://github.com/dallay/agentsync#readme",
+	"bugs": {
+		"url": "https://github.com/dallay/agentsync/issues"
+	},
+	"keywords": [
+		"ai",
+		"agents",
+		"symlink",
+		"configuration",
+		"cli",
+		"claude",
+		"copilot",
+		"gemini",
+		"cursor",
+		"opencode",
+		"mcp",
+		"mcp-server"
+	],
+	"bin": {
+		"agentsync": "lib/index.js"
+	},
+	"main": "lib/index.js",
+	"files": [
+		"lib"
+	],
+	"scripts": {
+		"test": "pnpm run typecheck",
+		"typecheck": "tsc --noEmit",
+		"build": "tsc",
+		"clean": "node -e \"require('fs').rmSync('lib', {recursive: true, force: true})\"",
+		"prepublishOnly": "npm run build"
+	},
+	"devDependencies": {
+		"@types/node": "^24.1.0",
+		"typescript": "^5.9.3"
+	},
+	"optionalDependencies": {
+		"@dallay/agentsync-linux-x64": "1.28.0",
+		"@dallay/agentsync-linux-arm64": "1.28.0",
+		"@dallay/agentsync-darwin-x64": "1.28.0",
+		"@dallay/agentsync-darwin-arm64": "1.28.0",
+		"@dallay/agentsync-windows-x64": "1.28.0",
+		"@dallay/agentsync-windows-arm64": "1.28.0"
+	},
+	"engines": {
+		"node": ">=18"
+	}
 }

scripts/bench_setup.py

@@ -0,0 +1,30 @@
+
+import os
+
+# Create a large AGENTS.md
+agents_md_content = "# Project Agents\n\n" + "\n".join([f"## Agent {i}\nThis is agent {i} configuration." for i in range(1000)])
+os.makedirs(".agents", exist_ok=True)
+with open(".agents/AGENTS.md", "w") as f:
+    f.write(agents_md_content)
+
+# Create agentsync.toml with many agents
+config = """
+source_dir = "."
+compress_agents_md = true
+
+[gitignore]
+enabled = false
+"""
+
+for i in range(100):
+    config += f"""
+[agents.agent{i}]
+enabled = true
+[agents.agent{i}.targets.main]
+source = "AGENTS.md"
+destination = "agent{i}.md"
+type = "symlink"
+"""
+
+with open(".agents/agentsync.toml", "w") as f:
+    f.write(config)