agentsync-cli 0.1.0__py3-none-any.whl

agentsync/__init__.py

@@ -0,0 +1,3 @@
+"""agentsync — Sync MCP server configs and rules across AI coding agents."""
+
+__version__ = "0.1.0"

agentsync/adapters/__init__.py

@@ -0,0 +1,13 @@
+"""Source and target adapters for different AI coding agents."""
+
+from agentsync.adapters.antigravity import AntigravityTargetAdapter
+from agentsync.adapters.claude import ClaudeSourceAdapter
+from agentsync.adapters.codex import CodexTargetAdapter
+from agentsync.adapters.cursor import CursorTargetAdapter
+
+__all__ = [
+    "AntigravityTargetAdapter",
+    "ClaudeSourceAdapter",
+    "CodexTargetAdapter",
+    "CursorTargetAdapter",
+]

agentsync/adapters/antigravity.py

@@ -0,0 +1,102 @@
+"""Antigravity/Gemini target adapter — JSON MCP config (stdio only)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agentsync.adapters.base import (
+    Section,
+    ServerConfig,
+    TargetAdapter,
+    ValidationResult,
+    WriteResult,
+)
+from agentsync.config import AgentSyncConfig, TargetConfig, resolve_path
+from agentsync.utils.io import write_json
+from agentsync.utils.logger import SilentLogger, SyncLogger
+from agentsync.validate import check_server_consistency
+
+
+class AntigravityTargetAdapter(TargetAdapter):
+    """Writes MCP servers as JSON for Antigravity/Gemini. Rules are not supported."""
+
+    def __init__(
+        self,
+        target_config: TargetConfig,
+        config: AgentSyncConfig,
+        logger: SyncLogger | None = None,
+    ) -> None:
+        self._tc = target_config
+        self._config = config
+        self._log = logger or SilentLogger()
+        self._mcp_data: dict[str, Any] | None = None
+
+    # ------------------------------------------------------------------
+    # TargetAdapter interface
+    # ------------------------------------------------------------------
+
+    def generate_mcp(self, servers: dict[str, ServerConfig]) -> dict[str, Any]:
+        data = {"mcpServers": {n: s.config for n, s in servers.items()}}
+        self._mcp_data = data
+        return data
+
+    def generate_rules(self, sections: list[Section]) -> str:
+        return ""
+
+    def write(self, dry_run: bool = False) -> list[WriteResult]:
+        results: list[WriteResult] = []
+        backup_dir = self._backup_dir()
+
+        if self._mcp_data is not None and self._tc.mcp_path:
+            path = resolve_path(self._tc.mcp_path, self._config.config_dir)
+            results.append(write_json(path, self._mcp_data, self._log, backup_dir, dry_run))
+
+        # Rules are not supported — skip entirely
+        return results
+
+    def validate(self) -> list[ValidationResult]:
+        results: list[ValidationResult] = []
+
+        mcp_path = (
+            resolve_path(self._tc.mcp_path, self._config.config_dir) if self._tc.mcp_path else None
+        )
+        if mcp_path and mcp_path.is_file():
+            try:
+                data = json.loads(mcp_path.read_text(encoding="utf-8"))
+                actual = set(data.get("mcpServers", {}))
+            except (json.JSONDecodeError, OSError):
+                actual = set()
+
+            expected = self._load_expected_servers()
+            exclude = set(self._tc.exclude_servers)
+            results.append(
+                check_server_consistency(expected, actual, "antigravity", exclude, stdio_only=True)
+            )
+        else:
+            results.append(
+                ValidationResult(
+                    name="antigravity mcp file",
+                    passed=True,
+                    message="MCP file does not exist yet",
+                    severity="info",
+                )
+            )
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _backup_dir(self) -> Path | None:
+        if not self._config.sync.backup:
+            return None
+        return resolve_path(self._config.sync.backup_dir, self._config.config_dir)
+
+    def _load_expected_servers(self) -> dict[str, ServerConfig]:
+        from agentsync.adapters.claude import ClaudeSourceAdapter
+
+        source = ClaudeSourceAdapter(self._config)
+        return source.load_servers()

agentsync/adapters/base.py

@@ -0,0 +1,84 @@
+"""Abstract base classes for source and target adapters."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ServerConfig:
+    """Represents an MCP server configuration."""
+
+    name: str
+    config: dict[str, Any]
+
+    @property
+    def is_stdio(self) -> bool:
+        return "command" in self.config
+
+    @property
+    def is_http(self) -> bool:
+        return "url" in self.config
+
+
+@dataclass
+class Section:
+    """Represents a markdown section (## or ###)."""
+
+    header: str
+    level: int
+    content: str
+
+
+@dataclass
+class WriteResult:
+    """Result of a write operation."""
+
+    path: str
+    written: bool
+    bytes_written: int = 0
+    message: str = ""
+
+
+@dataclass
+class ValidationResult:
+    """Result of a single validation check."""
+
+    name: str
+    passed: bool
+    message: str
+    severity: str = "error"  # error, warning, info
+
+
+class SourceAdapter(ABC):
+    """Base class for source adapters (e.g., Claude Code)."""
+
+    @abstractmethod
+    def load_servers(self) -> dict[str, ServerConfig]:
+        """Load MCP servers from source."""
+
+    @abstractmethod
+    def load_rules(self) -> list[Section]:
+        """Load rules/sections from source."""
+
+
+class TargetAdapter(ABC):
+    """Base class for target adapters (e.g., Cursor, Codex)."""
+
+    @abstractmethod
+    def generate_mcp(self, servers: dict[str, ServerConfig]) -> str | dict[str, Any]:
+        """Generate MCP config in target-specific format."""
+
+    @abstractmethod
+    def generate_rules(self, sections: list[Section]) -> str:
+        """Generate rules in target-specific format."""
+
+    @abstractmethod
+    def write(self, dry_run: bool = False) -> list[WriteResult]:
+        """Write generated configs to target paths."""
+
+    @abstractmethod
+    def validate(self) -> list[ValidationResult]:
+        """Validate existing target configs."""

agentsync/adapters/claude.py

@@ -0,0 +1,129 @@
+"""Claude Code source adapter — reads MCP servers and rules."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agentsync.adapters.base import Section, ServerConfig, SourceAdapter
+from agentsync.config import AgentSyncConfig, resolve_path
+from agentsync.utils.logger import SilentLogger, SyncLogger
+from agentsync.utils.markdown import parse_markdown_sections
+
+
+class ClaudeSourceAdapter(SourceAdapter):
+    """Reads MCP servers and rules from Claude Code configuration files.
+
+    MCP servers are merged from three tiers (lowest → highest priority):
+    1. ``~/.claude.json`` top-level ``mcpServers``  (global)
+    2. ``~/.claude.json`` → ``projects[config_dir].mcpServers``  (project-specific)
+    3. ``.mcp.json`` → ``mcpServers``  (local project override)
+
+    Rules are parsed from ``CLAUDE.md`` via :func:`parse_markdown_sections`.
+    """
+
+    def __init__(
+        self,
+        config: AgentSyncConfig,
+        logger: SyncLogger | None = None,
+    ) -> None:
+        self._config = config
+        self._log = logger or SilentLogger()
+
+    # ------------------------------------------------------------------
+    # SourceAdapter interface
+    # ------------------------------------------------------------------
+
+    def load_servers(self) -> dict[str, ServerConfig]:
+        """Load and merge MCP servers from all three tiers."""
+        merged: dict[str, ServerConfig] = {}
+
+        # Tier 1 & 2: ~/.claude.json (global + project-specific)
+        global_path = resolve_path(self._config.source.global_config, self._config.config_dir)
+        global_data = self._read_json(global_path)
+
+        if global_data is not None:
+            # Tier 1: top-level mcpServers
+            top_level = global_data.get("mcpServers", {})
+            if isinstance(top_level, dict):
+                merged.update(self._extract_servers(top_level))
+                self._log.info(f"Global config: {len(top_level)} servers from {global_path}")
+
+            # Tier 2: projects[config_dir].mcpServers
+            projects = global_data.get("projects", {})
+            if isinstance(projects, dict):
+                project_key = str(self._config.config_dir)
+                project_block = projects.get(project_key, {})
+                if isinstance(project_block, dict):
+                    project_servers = project_block.get("mcpServers", {})
+                    if isinstance(project_servers, dict) and project_servers:
+                        extracted = self._extract_servers(project_servers)
+                        merged.update(extracted)
+                        self._log.info(
+                            f"Project config: {len(project_servers)} servers for {project_key}"
+                        )
+
+        # Tier 3: .mcp.json (highest priority)
+        mcp_path = resolve_path(self._config.source.project_mcp, self._config.config_dir)
+        mcp_data = self._read_json(mcp_path)
+
+        if mcp_data is not None:
+            local_servers = mcp_data.get("mcpServers", {})
+            if isinstance(local_servers, dict):
+                merged.update(self._extract_servers(local_servers))
+                self._log.info(f"Local .mcp.json: {len(local_servers)} servers from {mcp_path}")
+
+        return merged
+
+    def load_rules(self) -> list[Section]:
+        """Load and parse rules from CLAUDE.md."""
+        rules_path = resolve_path(self._config.source.rules_file, self._config.config_dir)
+
+        if not rules_path.is_file():
+            self._log.warn(f"Rules file not found: {rules_path}")
+            return []
+
+        try:
+            content = rules_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            self._log.warn(f"Cannot read {rules_path}: {exc}")
+            return []
+
+        if not content.strip():
+            self._log.warn(f"Rules file is empty: {rules_path}")
+            return []
+
+        sections = parse_markdown_sections(content)
+        self._log.info(f"Loaded {len(sections)} sections from {rules_path}")
+        return sections
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _read_json(self, path: Path) -> dict[str, Any] | None:
+        """Safely read a JSON file. Returns None on missing file or invalid JSON."""
+        if not path.is_file():
+            self._log.warn(f"File not found: {path}")
+            return None
+
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError, UnicodeDecodeError) as exc:
+            self._log.warn(f"Cannot read {path}: {exc}")
+            return None
+
+        if not isinstance(raw, dict):
+            self._log.warn(f"Expected JSON object in {path}, got {type(raw).__name__}")
+            return None
+
+        return raw
+
+    def _extract_servers(self, raw: dict[str, Any]) -> dict[str, ServerConfig]:
+        """Convert a raw ``mcpServers`` dict into ``{name: ServerConfig}``."""
+        result: dict[str, ServerConfig] = {}
+        for name, cfg in raw.items():
+            if isinstance(cfg, dict):
+                result[name] = ServerConfig(name=name, config=cfg)
+        return result

agentsync/adapters/codex.py

@@ -0,0 +1,178 @@
+"""Codex target adapter — TOML MCP config + Markdown rules."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from agentsync.adapters.base import (
+    Section,
+    ServerConfig,
+    TargetAdapter,
+    ValidationResult,
+    WriteResult,
+)
+from agentsync.config import AgentSyncConfig, TargetConfig, resolve_path
+from agentsync.utils.io import write_text
+from agentsync.utils.logger import SilentLogger, SyncLogger
+from agentsync.validate import check_server_consistency
+
+MARKER_START = "# === AGENTSYNC START ==="
+MARKER_END = "# === AGENTSYNC END ==="
+
+
+class CodexTargetAdapter(TargetAdapter):
+    """Writes MCP servers as TOML (with markers) and rules as Markdown for Codex."""
+
+    def __init__(
+        self,
+        target_config: TargetConfig,
+        config: AgentSyncConfig,
+        logger: SyncLogger | None = None,
+    ) -> None:
+        self._tc = target_config
+        self._config = config
+        self._log = logger or SilentLogger()
+        self._mcp_text: str | None = None
+        self._rules_text: str | None = None
+
+    # ------------------------------------------------------------------
+    # TargetAdapter interface
+    # ------------------------------------------------------------------
+
+    def generate_mcp(self, servers: dict[str, ServerConfig]) -> str:
+        lines: list[str] = []
+        for name, sc in servers.items():
+            lines.append(_server_to_toml(name, sc.config))
+        inner = "\n".join(lines)
+        self._mcp_text = f"{MARKER_START}\n{inner}\n{MARKER_END}\n"
+        return self._mcp_text
+
+    def generate_rules(self, sections: list[Section]) -> str:
+        text = "\n\n".join(s.content for s in sections)
+        self._rules_text = text + "\n" if text else ""
+        return self._rules_text
+
+    def write(self, dry_run: bool = False) -> list[WriteResult]:
+        results: list[WriteResult] = []
+        backup_dir = self._backup_dir()
+
+        if self._mcp_text is not None and self._tc.config_path:
+            path = resolve_path(self._tc.config_path, self._config.config_dir)
+            content = self._merge_toml(path, self._mcp_text)
+            results.append(write_text(path, content, self._log, backup_dir, dry_run))
+
+        if self._rules_text is not None and self._tc.rules_path:
+            path = resolve_path(self._tc.rules_path, self._config.config_dir)
+            results.append(write_text(path, self._rules_text, self._log, backup_dir, dry_run))
+
+        return results
+
+    def validate(self) -> list[ValidationResult]:
+        results: list[ValidationResult] = []
+
+        config_path = (
+            resolve_path(self._tc.config_path, self._config.config_dir)
+            if self._tc.config_path
+            else None
+        )
+        if config_path and config_path.is_file():
+            content = config_path.read_text(encoding="utf-8")
+            if MARKER_START in content and MARKER_END in content:
+                actual = _extract_server_names(content)
+                expected = self._load_expected_servers()
+                exclude = set(self._tc.exclude_servers)
+                results.append(check_server_consistency(expected, actual, "codex", exclude))
+            else:
+                results.append(
+                    ValidationResult(
+                        name="codex markers",
+                        passed=True,
+                        message="No agentsync markers found in config.toml",
+                        severity="warning",
+                    )
+                )
+        else:
+            results.append(
+                ValidationResult(
+                    name="codex config file",
+                    passed=True,
+                    message="Config file does not exist yet",
+                    severity="info",
+                )
+            )
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _merge_toml(self, path: Path, managed_block: str) -> str:
+        """Merge managed block into existing TOML, or create a new file."""
+        if not path.is_file():
+            return managed_block
+
+        existing = path.read_text(encoding="utf-8")
+        if MARKER_START in existing and MARKER_END in existing:
+            # Replace content between markers (inclusive)
+            pattern = re.escape(MARKER_START) + r".*?" + re.escape(MARKER_END) + r"\n?"
+            return re.sub(pattern, managed_block, existing, flags=re.DOTALL)
+
+        # No markers — append
+        sep = "" if existing.endswith("\n") else "\n"
+        return existing + sep + "\n" + managed_block
+
+    def _backup_dir(self) -> Path | None:
+        if not self._config.sync.backup:
+            return None
+        return resolve_path(self._config.sync.backup_dir, self._config.config_dir)
+
+    def _load_expected_servers(self) -> dict[str, ServerConfig]:
+        from agentsync.adapters.claude import ClaudeSourceAdapter
+
+        source = ClaudeSourceAdapter(self._config)
+        return source.load_servers()
+
+
+# ===================================================================
+# TOML helpers (no external dependencies — Python 3.9+)
+# ===================================================================
+
+
+def _toml_value(val: Any) -> str:
+    """Serialize a single Python value to TOML literal."""
+    if isinstance(val, bool):
+        return "true" if val else "false"
+    if isinstance(val, int):
+        return str(val)
+    if isinstance(val, float):
+        return str(val)
+    if isinstance(val, str):
+        # Escape backslashes and double quotes
+        escaped = val.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    if isinstance(val, list):
+        items = ", ".join(_toml_value(v) for v in val)
+        return f"[{items}]"
+    if isinstance(val, dict):
+        # Inline table
+        pairs = ", ".join(f"{k} = {_toml_value(v)}" for k, v in val.items())
+        return "{" + pairs + "}"
+    return repr(val)
+
+
+def _server_to_toml(name: str, config: dict[str, Any]) -> str:
+    """Render a single server config as a TOML table."""
+    # Codex uses underscores in table names
+    safe_name = name.replace("-", "_")
+    lines = [f"[mcp_servers.{safe_name}]"]
+    for key, val in config.items():
+        lines.append(f"{key} = {_toml_value(val)}")
+    return "\n".join(lines) + "\n"
+
+
+def _extract_server_names(content: str) -> set[str]:
+    """Extract server names from TOML [mcp_servers.xxx] headers."""
+    return set(re.findall(r"\[mcp_servers\.(.+?)\]", content))

agentsync/adapters/cursor.py

@@ -0,0 +1,137 @@
+"""Cursor target adapter — JSON MCP config + MDC rules."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agentsync.adapters.base import (
+    Section,
+    ServerConfig,
+    TargetAdapter,
+    ValidationResult,
+    WriteResult,
+)
+from agentsync.config import AgentSyncConfig, TargetConfig, resolve_path
+from agentsync.utils.io import write_json, write_text
+from agentsync.utils.logger import SilentLogger, SyncLogger
+from agentsync.validate import check_no_excluded_sections, check_server_consistency
+
+
+class CursorTargetAdapter(TargetAdapter):
+    """Writes MCP servers as JSON and rules as MDC or plain Markdown for Cursor."""
+
+    def __init__(
+        self,
+        target_config: TargetConfig,
+        config: AgentSyncConfig,
+        logger: SyncLogger | None = None,
+    ) -> None:
+        self._tc = target_config
+        self._config = config
+        self._log = logger or SilentLogger()
+        self._mcp_data: dict[str, Any] | None = None
+        self._rules_text: str | None = None
+
+    # ------------------------------------------------------------------
+    # TargetAdapter interface
+    # ------------------------------------------------------------------
+
+    def generate_mcp(self, servers: dict[str, ServerConfig]) -> dict[str, Any]:
+        data = {"mcpServers": {n: s.config for n, s in servers.items()}}
+        self._mcp_data = data
+        return data
+
+    def generate_rules(self, sections: list[Section]) -> str:
+        body = "\n\n".join(s.content for s in sections)
+        if self._tc.rules_format == "mdc":
+            frontmatter = (
+                "---\n"
+                'description: "Project rules — auto-generated by agentsync"\n'
+                "alwaysApply: true\n"
+                "---\n"
+            )
+            text = frontmatter + "\n" + body + "\n"
+        else:
+            text = body + "\n" if body else ""
+        self._rules_text = text
+        return text
+
+    def write(self, dry_run: bool = False) -> list[WriteResult]:
+        results: list[WriteResult] = []
+        backup_dir = self._backup_dir()
+
+        if self._mcp_data is not None and self._tc.mcp_path:
+            path = resolve_path(self._tc.mcp_path, self._config.config_dir)
+            results.append(write_json(path, self._mcp_data, self._log, backup_dir, dry_run))
+
+        if self._rules_text is not None and self._tc.rules_path:
+            path = resolve_path(self._tc.rules_path, self._config.config_dir)
+            results.append(write_text(path, self._rules_text, self._log, backup_dir, dry_run))
+
+        return results
+
+    def validate(self) -> list[ValidationResult]:
+        results: list[ValidationResult] = []
+
+        # MCP server consistency
+        mcp_path = (
+            resolve_path(self._tc.mcp_path, self._config.config_dir) if self._tc.mcp_path else None
+        )
+        if mcp_path and mcp_path.is_file():
+            try:
+                data = json.loads(mcp_path.read_text(encoding="utf-8"))
+                actual = set(data.get("mcpServers", {}))
+            except (json.JSONDecodeError, OSError):
+                actual = set()
+
+            expected = self._load_expected_servers()
+            exclude = set(self._tc.exclude_servers)
+            results.append(check_server_consistency(expected, actual, "cursor", exclude))
+        else:
+            results.append(
+                ValidationResult(
+                    name="cursor mcp file",
+                    passed=True,
+                    message="MCP file does not exist yet",
+                    severity="info",
+                )
+            )
+
+        # Excluded sections leak check
+        rules_path = (
+            resolve_path(self._tc.rules_path, self._config.config_dir)
+            if self._tc.rules_path
+            else None
+        )
+        if rules_path and rules_path.is_file():
+            content = rules_path.read_text(encoding="utf-8")
+            exclude_set = set(self._config.rules.exclude_sections)
+            results.append(check_no_excluded_sections(content, exclude_set, "cursor"))
+        else:
+            results.append(
+                ValidationResult(
+                    name="cursor rules file",
+                    passed=True,
+                    message="Rules file does not exist yet",
+                    severity="info",
+                )
+            )
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _backup_dir(self) -> Path | None:
+        if not self._config.sync.backup:
+            return None
+        return resolve_path(self._config.sync.backup_dir, self._config.config_dir)
+
+    def _load_expected_servers(self) -> dict[str, ServerConfig]:
+        from agentsync.adapters.claude import ClaudeSourceAdapter
+
+        source = ClaudeSourceAdapter(self._config)
+        return source.load_servers()