agentsync-cli 0.1.0__py3-none-any.whl

agentsync/sync.py

@@ -0,0 +1,164 @@
+"""Core sync orchestrator — loads source, deduplicates, generates targets."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from agentsync.adapters.base import ServerConfig, WriteResult
+from agentsync.utils.dedup import dedup_servers
+from agentsync.utils.markdown import filter_sections
+
+if TYPE_CHECKING:
+    from agentsync.adapters.base import SourceAdapter, TargetAdapter
+    from agentsync.config import AgentSyncConfig
+
+
+@dataclass
+class TargetSyncResult:
+    """Outcome of syncing a single target."""
+
+    target_name: str
+    success: bool
+    writes: list[WriteResult] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SyncResult:
+    """Aggregate outcome of a full sync run."""
+
+    success: bool
+    dry_run: bool
+    target_results: dict[str, TargetSyncResult] = field(default_factory=dict)
+
+
+class SyncEngine:
+    """Orchestrates sync from a single source to multiple targets."""
+
+    def __init__(
+        self,
+        config: AgentSyncConfig,
+        source: SourceAdapter,
+        targets: dict[str, TargetAdapter],
+    ) -> None:
+        self._config = config
+        self._source = source
+        self._targets = targets
+
+    # ------------------------------------------------------------------
+    # Public
+    # ------------------------------------------------------------------
+
+    def run(
+        self,
+        *,
+        dry_run: bool = False,
+        mcp_only: bool = False,
+        rules_only: bool = False,
+        target_filter: str | None = None,
+        quiet: bool = False,
+    ) -> SyncResult:
+        """Execute the sync pipeline.
+
+        Returns a :class:`SyncResult` summarising what happened.
+        """
+        from agentsync.utils.logger import SyncLogger
+
+        log = SyncLogger(dry_run=dry_run, quiet=quiet)
+        result = SyncResult(success=True, dry_run=dry_run)
+
+        # Determine which targets to process
+        target_names = list(self._targets)
+        if target_filter:
+            if target_filter not in self._targets:
+                log.error(f"Unknown target '{target_filter}'")
+                result.success = False
+                return result
+            target_names = [target_filter]
+
+        # --- MCP servers ---
+        servers: dict[str, ServerConfig] = {}
+        if not rules_only:
+            log.section("Loading MCP servers")
+            servers = self._source.load_servers()
+            servers = dedup_servers(servers, log)
+            log.info(f"Total: {len(servers)} unique servers after dedup")
+
+        # --- Rules (sections) ---
+        all_sections = []
+        if not mcp_only:
+            log.section("Loading rules")
+            all_sections = self._source.load_rules()
+            log.info(f"Loaded {len(all_sections)} sections from source")
+
+        # --- Per-target processing ---
+        for name in target_names:
+            target = self._targets[name]
+            tr = TargetSyncResult(target_name=name, success=True)
+
+            log.section(f"Target: {name}")
+
+            try:
+                # MCP
+                if not rules_only and servers:
+                    filtered_servers = self._filter_servers(servers, name)
+                    log.info(
+                        f"{len(filtered_servers)}/{len(servers)} servers after filtering for {name}"
+                    )
+                    target.generate_mcp(filtered_servers)
+
+                # Rules
+                if not mcp_only and all_sections:
+                    exclude_set = set(self._config.rules.exclude_sections)
+                    filtered = filter_sections(all_sections, exclude_set)
+                    log.info(
+                        f"{len(filtered)}/{len(all_sections)} sections after filtering for {name}"
+                    )
+                    target.generate_rules(filtered)
+
+                # Write
+                writes = target.write(dry_run=dry_run)
+                tr.writes = writes
+
+            except Exception as exc:  # noqa: BLE001
+                tr.success = False
+                tr.errors.append(str(exc))
+                log.error(f"{name}: {exc}")
+
+            result.target_results[name] = tr
+            if not tr.success:
+                result.success = False
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _filter_servers(
+        self,
+        servers: dict[str, ServerConfig],
+        target_name: str,
+    ) -> dict[str, ServerConfig]:
+        """Apply per-target exclude_servers and protocol filtering."""
+        target_cfg = self._config.targets.get(target_name)
+        if target_cfg is None:
+            return servers
+
+        exclude = {s.lower() for s in target_cfg.exclude_servers}
+        protocols = {p.lower() for p in target_cfg.protocols}
+
+        filtered: dict[str, ServerConfig] = {}
+        for key, sc in servers.items():
+            if key.lower() in exclude:
+                continue
+            if protocols:
+                matches = ("stdio" in protocols and sc.is_stdio) or (
+                    "http" in protocols and sc.is_http
+                )
+                if not matches:
+                    continue
+            filtered[key] = sc
+
+        return filtered

agentsync/utils/__init__.py

@@ -0,0 +1 @@
+"""Shared utilities for agentsync."""

agentsync/utils/backup.py

@@ -0,0 +1,29 @@
+"""File backup utilities."""
+
+from __future__ import annotations
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from agentsync.utils.logger import SyncLogger
+
+
+def backup_file(path: Path, backup_dir: Path, log: SyncLogger) -> Path | None:
+    """Create a timestamped backup of *path* inside *backup_dir*.
+
+    Returns the backup path on success, or ``None`` if the source file
+    does not exist.
+    """
+    if not path.exists():
+        return None
+
+    backup_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_name = f"{path.name}.{timestamp}.bak"
+    backup_path = backup_dir / backup_name
+    shutil.copy2(path, backup_path)
+    log.info(f"Backup: {path} -> {backup_path}")
+    return backup_path

agentsync/utils/dedup.py

@@ -0,0 +1,32 @@
+"""Case-insensitive server deduplication."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from agentsync.adapters.base import ServerConfig
+
+if TYPE_CHECKING:
+    from agentsync.utils.logger import SyncLogger
+
+
+def dedup_servers(
+    servers: dict[str, ServerConfig],
+    log: SyncLogger,
+) -> dict[str, ServerConfig]:
+    """Deduplicate servers by case-insensitive key comparison.
+
+    When two keys differ only by case (e.g. ``Notion`` vs ``notion``),
+    the later entry wins.  All returned keys are lowercase.
+    """
+    seen: dict[str, tuple[str, ServerConfig]] = {}
+
+    for key, sc in servers.items():
+        lower = key.lower()
+        if lower in seen:
+            prev_key = seen[lower][0]
+            if prev_key != key:
+                log.warn(f"Dedup: '{prev_key}' replaced by '{key}' (case-insensitive merge)")
+        seen[lower] = (key, sc)
+
+    return {lower: sc for lower, (_orig, sc) in seen.items()}

agentsync/utils/diff.py

@@ -0,0 +1,44 @@
+"""Server diff display utilities."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from agentsync.adapters.base import ServerConfig
+
+if TYPE_CHECKING:
+    from agentsync.utils.logger import SyncLogger
+
+
+def show_server_diff(
+    target_name: str,
+    existing_path: Path,
+    new_servers: dict[str, ServerConfig],
+    log: SyncLogger,
+) -> None:
+    """Log which servers are added/removed compared to an existing JSON file."""
+    new_names = set(new_servers)
+
+    if not existing_path.exists():
+        log.info(
+            f"{target_name}: file doesn't exist yet, will create with {len(new_names)} servers"
+        )
+        return
+
+    try:
+        data = json.loads(existing_path.read_text())
+        existing_names: set[str] = set(data.get("mcpServers", {}))
+    except (json.JSONDecodeError, KeyError):
+        existing_names = set()
+
+    added = new_names - existing_names
+    removed = existing_names - new_names
+
+    if added:
+        log.info(f"{target_name}: +{len(added)} servers ({', '.join(sorted(added))})")
+    if removed:
+        log.info(f"{target_name}: -{len(removed)} servers ({', '.join(sorted(removed))})")
+    if not added and not removed:
+        log.info(f"{target_name}: same {len(new_names)} servers")

agentsync/utils/io.py

@@ -0,0 +1,88 @@
+"""File writing utilities that return WriteResult."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from agentsync.adapters.base import WriteResult
+from agentsync.utils.backup import backup_file
+
+if TYPE_CHECKING:
+    from agentsync.utils.logger import SyncLogger
+
+
+def write_json(
+    path: Path,
+    data: Any,
+    log: SyncLogger,
+    backup_dir: Path | None = None,
+    dry_run: bool = False,
+) -> WriteResult:
+    """Serialize *data* as JSON and write to *path*.
+
+    Returns a :class:`WriteResult` describing the outcome.
+    """
+    content = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+
+    # Validate round-trip
+    try:
+        json.loads(content)
+    except json.JSONDecodeError as e:
+        msg = f"JSON validation failed for {path}: {e}"
+        log.error(msg)
+        return WriteResult(path=str(path), written=False, message=msg)
+
+    return _write(path, content, log, backup_dir=backup_dir, dry_run=dry_run)
+
+
+def write_text(
+    path: Path,
+    content: str,
+    log: SyncLogger,
+    backup_dir: Path | None = None,
+    dry_run: bool = False,
+) -> WriteResult:
+    """Write plain text to *path*.
+
+    Returns a :class:`WriteResult` describing the outcome.
+    """
+    return _write(path, content, log, backup_dir=backup_dir, dry_run=dry_run)
+
+
+# ------------------------------------------------------------------
+# Internal helper
+# ------------------------------------------------------------------
+
+
+def _write(
+    path: Path,
+    content: str,
+    log: SyncLogger,
+    *,
+    backup_dir: Path | None,
+    dry_run: bool,
+) -> WriteResult:
+    nbytes = len(content.encode())
+
+    if dry_run:
+        if path.exists():
+            existing = path.read_text()
+            if existing == content:
+                msg = f"{path}: no changes"
+            else:
+                msg = f"{path}: WOULD UPDATE ({nbytes} bytes)"
+        else:
+            msg = f"{path}: WOULD CREATE ({nbytes} bytes)"
+        log.info(msg)
+        return WriteResult(path=str(path), written=False, bytes_written=0, message=msg)
+
+    if backup_dir is not None:
+        backup_file(path, backup_dir, log)
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+    msg = f"Written: {path} ({nbytes} bytes)"
+    log.info(msg)
+    return WriteResult(path=str(path), written=True, bytes_written=nbytes, message=msg)

agentsync/utils/logger.py

@@ -0,0 +1,56 @@
+"""Rich-based logging utilities for agentsync."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Console
+from rich.rule import Rule
+
+
+class SyncLogger:
+    """Logger with rich console output and optional file flushing."""
+
+    def __init__(self, dry_run: bool = False, quiet: bool = False) -> None:
+        self.dry_run = dry_run
+        self.quiet = quiet
+        self._console = Console(quiet=quiet)
+        self._buffer: list[str] = []
+
+    def _record(self, msg: str, level: str = "INFO") -> None:
+        prefix = "[DRY-RUN] " if self.dry_run else ""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self._buffer.append(f"[{timestamp}] [{level}] {prefix}{msg}")
+
+    def info(self, msg: str) -> None:
+        self._record(msg, "INFO")
+        self._console.print(f"  [green]INFO[/green]  {msg}")
+
+    def warn(self, msg: str) -> None:
+        self._record(msg, "WARN")
+        self._console.print(f"  [yellow]WARN[/yellow]  {msg}")
+
+    def error(self, msg: str) -> None:
+        self._record(msg, "ERROR")
+        self._console.print(f"  [red]ERROR[/red] {msg}")
+
+    def section(self, title: str) -> None:
+        self._record(f"=== {title} ===")
+        self._console.print(Rule(title))
+
+    def flush_to_file(self, log_dir: Path) -> None:
+        """Write buffered messages to a dated log file."""
+        if not self._buffer:
+            return
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / f"sync-{datetime.now().strftime('%Y-%m-%d')}.log"
+        with open(log_file, "a") as f:
+            f.write("\n".join(self._buffer) + "\n")
+
+
+class SilentLogger(SyncLogger):
+    """Suppresses console output; buffer is still preserved for flush_to_file."""
+
+    def __init__(self, dry_run: bool = False) -> None:
+        super().__init__(dry_run=dry_run, quiet=True)

agentsync/utils/markdown.py

@@ -0,0 +1,91 @@
+"""Markdown section parsing and filtering — pure functions, no I/O."""
+
+from __future__ import annotations
+
+from agentsync.adapters.base import Section
+
+
+def parse_markdown_sections(content: str) -> list[Section]:
+    """Parse markdown *content* into a flat list of :class:`Section` objects.
+
+    Recognises ``##`` (level 2) and ``###`` (level 3) headers.  Content
+    before the first header (the preamble) is silently discarded.
+    """
+    lines = content.split("\n")
+    sections: list[Section] = []
+    current_header: str | None = None
+    current_level: int = 0
+    current_lines: list[str] = []
+
+    for line in lines:
+        if line.startswith("### "):
+            # Flush previous section
+            if current_header is not None:
+                sections.append(
+                    Section(
+                        header=current_header,
+                        level=current_level,
+                        content="\n".join(current_lines),
+                    )
+                )
+            current_header = line[4:].strip()
+            current_level = 3
+            current_lines = [line]
+        elif line.startswith("## "):
+            if current_header is not None:
+                sections.append(
+                    Section(
+                        header=current_header,
+                        level=current_level,
+                        content="\n".join(current_lines),
+                    )
+                )
+            current_header = line[3:].strip()
+            current_level = 2
+            current_lines = [line]
+        elif current_header is not None:
+            current_lines.append(line)
+
+    # Flush last section
+    if current_header is not None:
+        sections.append(
+            Section(
+                header=current_header,
+                level=current_level,
+                content="\n".join(current_lines),
+            )
+        )
+
+    return sections
+
+
+def filter_sections(sections: list[Section], exclude_set: set[str]) -> list[Section]:
+    """Filter out sections whose headers appear in *exclude_set*.
+
+    When a level-2 (``##``) section is excluded, all its level-3 children
+    are excluded too.  A level-3 section listed explicitly is removed on
+    its own without affecting siblings.
+    """
+    filtered: list[Section] = []
+    skip_parent = False
+
+    for section in sections:
+        # Level-2: toggle parent skip flag
+        if section.level == 2:
+            if section.header in exclude_set:
+                skip_parent = True
+                continue
+            else:
+                skip_parent = False
+
+        # Level-3 under an excluded parent
+        if skip_parent and section.level == 3:
+            continue
+
+        # Level-3 excluded individually
+        if section.header in exclude_set:
+            continue
+
+        filtered.append(section)
+
+    return filtered

agentsync/utils/output.py

@@ -0,0 +1,159 @@
+"""Rich output helpers for CLI commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from agentsync.adapters.base import SourceAdapter, TargetAdapter
+    from agentsync.config import AgentSyncConfig
+    from agentsync.sync import SyncResult
+    from agentsync.validate import ValidationReport
+
+
+def print_sync_summary(result: SyncResult, console: Console | None = None) -> None:
+    """Print a coloured summary of sync results."""
+    con = console or Console()
+
+    total_files = 0
+    total_errors = 0
+
+    for tr in result.target_results.values():
+        total_files += sum(1 for w in tr.writes if w.written)
+        total_errors += len(tr.errors)
+
+    n_targets = len(result.target_results)
+    header = f"Sync complete: {n_targets} target{'s' if n_targets != 1 else ''}"
+    header += f", {total_files} file{'s' if total_files != 1 else ''} written"
+    if total_errors:
+        header += f", [red]{total_errors} error{'s' if total_errors != 1 else ''}[/red]"
+    else:
+        header += ", 0 errors"
+
+    con.print()
+    con.print(header)
+
+    for name, tr in result.target_results.items():
+        n_written = sum(1 for w in tr.writes if w.written)
+        if tr.success:
+            mark = "[green]\u2713[/green]"
+            detail = f"{n_written} file{'s' if n_written != 1 else ''}"
+        else:
+            mark = "[red]\u2717[/red]"
+            detail = "; ".join(tr.errors) if tr.errors else "failed"
+
+        con.print(f"  {name:<16} {mark}  {detail}")
+
+    if result.dry_run:
+        con.print()
+        con.print("[yellow]DRY RUN \u2014 no files were written[/yellow]")
+
+
+def print_validation_report(
+    report: ValidationReport,
+    verbose: bool = False,
+    console: Console | None = None,
+) -> None:
+    """Print a coloured validation report."""
+    con = console or Console()
+
+    passed = sum(1 for r in report.results if r.passed)
+    failed = sum(1 for r in report.results if not r.passed)
+
+    con.print()
+
+    for r in report.results:
+        if r.passed and not verbose:
+            continue
+        mark = "[green]\u2713[/green]" if r.passed else "[red]\u2717[/red]"
+        con.print(f"  {mark} {r.name}: {r.message}")
+
+    con.print()
+    parts = []
+    if passed:
+        parts.append(f"[green]{passed} passed[/green]")
+    if failed:
+        parts.append(f"[red]{failed} failed[/red]")
+    con.print(f"Validation: {', '.join(parts)}")
+
+
+def print_status(
+    config: AgentSyncConfig,
+    source: SourceAdapter,
+    targets: dict[str, TargetAdapter],
+    console: Console | None = None,
+) -> None:
+    """Print current sync status: source info and per-target state."""
+    from agentsync.config import resolve_path
+
+    con = console or Console()
+
+    # --- Source ---
+    con.print()
+    con.print(f"[bold]Source:[/bold] {config.source.type}")
+
+    global_path = resolve_path(config.source.global_config, config.config_dir)
+    _print_path_status(con, "Global config", global_path)
+
+    project_mcp = resolve_path(config.source.project_mcp, config.config_dir)
+    server_count = None
+    if project_mcp.is_file():
+        try:
+            servers = source.load_servers()
+            server_count = len(servers)
+        except Exception:  # noqa: BLE001
+            server_count = None
+    _print_path_status(con, "Project MCP", project_mcp, extra_count=server_count)
+
+    rules_path = resolve_path(config.source.rules_file, config.config_dir)
+    _print_path_status(con, "Rules", rules_path)
+
+    # --- Targets ---
+    con.print()
+    con.print("[bold]Targets:[/bold]")
+
+    table = Table(show_header=True, show_edge=False, pad_edge=False, box=None)
+    table.add_column("Name", style="cyan", min_width=14)
+    table.add_column("Status", min_width=10)
+    table.add_column("Details")
+
+    for name, target in targets.items():
+        try:
+            results = target.validate()
+            all_pass = all(r.passed for r in results)
+            if not results:
+                mark = "[yellow]\u26a0[/yellow]"
+                detail = "no validation checks"
+            elif all_pass:
+                mark = "[green]\u2713[/green]"
+                detail = f"{len(results)} check{'s' if len(results) != 1 else ''} passed"
+            else:
+                n_fail = sum(1 for r in results if not r.passed)
+                mark = "[red]\u2717[/red]"
+                detail = f"{n_fail} check{'s' if n_fail != 1 else ''} failed"
+        except Exception as exc:  # noqa: BLE001
+            mark = "[red]\u2717[/red]"
+            detail = str(exc)
+
+        table.add_row(name, mark, detail)
+
+    con.print(table)
+
+
+def _print_path_status(
+    con: Console,
+    label: str,
+    path: Path,
+    *,
+    extra_count: int | None = None,
+) -> None:
+    """Print a source path with exists/missing indicator."""
+    if path.is_file():
+        suffix = f" ({extra_count} servers)" if extra_count is not None else ""
+        con.print(f"  {label + ':':<18} {path} [green](exists{suffix})[/green]")
+    else:
+        con.print(f"  {label + ':':<18} {path} [yellow](missing)[/yellow]")