code-agnostic 0.1.0__py3-none-any.whl

code_agnostic/models.py

@@ -0,0 +1,179 @@
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
+
+
+class ActionKind(str, Enum):
+    WRITE_JSON = "write_json"
+    SYMLINK = "symlink"
+    REMOVE_SYMLINK = "remove_symlink"
+
+
+class ActionStatus(str, Enum):
+    NOOP = "noop"
+    CREATE = "create"
+    UPDATE = "update"
+    FIX = "fix"
+    CONFLICT = "conflict"
+    REMOVE = "remove"
+
+
+class SyncTarget(str, Enum):
+    ALL = "all"
+    OPENCODE = "opencode"
+
+
+class EditorSyncStatus(str, Enum):
+    SYNCED = "synced"
+    DRIFT = "drift"
+    DISABLED = "disabled"
+    ERROR = "error"
+
+
+class WorkspaceSyncStatus(str, Enum):
+    SYNCED = "synced"
+    DRIFT = "drift"
+    ERROR = "error"
+
+
+class RepoSyncStatus(str, Enum):
+    SYNCED = "synced"
+    NEEDS_SYNC = "needs_sync"
+
+
+class AppId(str, Enum):
+    OPENCODE = "opencode"
+    CURSOR = "cursor"
+
+
+class AppSyncStatus(str, Enum):
+    ENABLED = "enabled"
+    DISABLED = "disabled"
+
+
+@dataclass
+class Action:
+    kind: ActionKind
+    path: Path
+    status: ActionStatus
+    detail: str
+    source: Optional[Path] = None
+    payload: Optional[Any] = None
+
+
+@dataclass
+class SyncPlan:
+    actions: list[Action]
+    errors: list[Exception]
+    skipped: list[str]
+
+    def is_valid(self) -> bool:
+        return not self.errors
+
+    def summary(self) -> dict[str, int]:
+        counts = {status.value: 0 for status in ActionStatus}
+        for action in self.actions:
+            counts[action.status.value] += 1
+        counts["actions"] = len(self.actions)
+        counts["errors"] = len(self.errors)
+        counts["skipped"] = len(self.skipped)
+        return counts
+
+    def filter_for_target(self, target: SyncTarget, config_path: Path, skills_root: Path, agents_root: Path) -> "SyncPlan":
+        if target == SyncTarget.ALL:
+            return self
+        if target != SyncTarget.OPENCODE:
+            return SyncPlan(actions=[], errors=self.errors, skipped=self.skipped)
+
+        resolved_skills = skills_root.resolve()
+        resolved_agents = agents_root.resolve()
+        filtered_actions: list[Action] = []
+        for action in self.actions:
+            if action.path == config_path:
+                filtered_actions.append(action)
+                continue
+            try:
+                resolved_path = action.path.resolve()
+            except Exception:
+                resolved_path = action.path
+            if _is_under(resolved_path, resolved_skills) or _is_under(resolved_path, resolved_agents):
+                filtered_actions.append(action)
+        return SyncPlan(actions=filtered_actions, errors=self.errors, skipped=self.skipped)
+
+
+PlanResult = SyncPlan
+
+
+@dataclass(frozen=True)
+class WorkspaceConfig:
+    name: str
+    path: Path
+
+
+@dataclass(frozen=True)
+class EditorStatusRow:
+    name: str
+    status: EditorSyncStatus
+    detail: str
+
+    def as_dict(self) -> dict[str, str]:
+        return {
+            "name": self.name,
+            "status": self.status.value,
+            "detail": self.detail,
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceRepoStatusRow:
+    repo: str
+    status: RepoSyncStatus
+    detail: str
+
+    def as_dict(self) -> dict[str, str]:
+        return {
+            "repo": self.repo,
+            "status": self.status.value,
+            "detail": self.detail,
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceStatusRow:
+    name: str
+    path: str
+    status: WorkspaceSyncStatus
+    detail: str
+    repos: list[WorkspaceRepoStatusRow]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "path": self.path,
+            "status": self.status.value,
+            "detail": self.detail,
+            "repos": [repo.as_dict() for repo in self.repos],
+        }
+
+
+@dataclass(frozen=True)
+class AppStatusRow:
+    name: AppId
+    status: AppSyncStatus
+    detail: str
+
+    def as_dict(self) -> dict[str, str]:
+        return {
+            "name": self.name.value,
+            "status": self.status.value,
+            "detail": self.detail,
+        }
+
+
+def _is_under(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root.resolve())
+        return True
+    except Exception:
+        return False

code_agnostic/planner.py

@@ -0,0 +1,212 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from code_agnostic.constants import AGENTS_FILENAME, WORKSPACE_RULE_FILES_DISPLAY
+from code_agnostic.errors import SyncAppError
+from code_agnostic.mappers.base import IConfigMapper
+from code_agnostic.mappers.opencode import OpenCodeMapper
+from code_agnostic.models import Action, ActionKind, ActionStatus, SyncPlan, SyncTarget
+from code_agnostic.repositories.base import ISourceRepository, ITargetRepository
+from code_agnostic.utils import is_under, same_json
+from code_agnostic.workspaces import WorkspaceService
+
+
+def _canonical_target(path: Path) -> str:
+    return str(path.resolve())
+
+
+class SyncPlanner:
+    def __init__(
+        self,
+        common: ISourceRepository,
+        opencode: ITargetRepository,
+        mapper: Optional[IConfigMapper] = None,
+        workspace_service: Optional[WorkspaceService] = None,
+    ) -> None:
+        self.common = common
+        self.opencode = opencode
+        self.mapper = mapper or OpenCodeMapper()
+        self.workspace_service = workspace_service or WorkspaceService()
+
+        self.actions: list[Action] = []
+        self.errors: list[Exception] = []
+        self.skipped: list[str] = []
+
+        self._desired_skill_links: list[Path] = []
+        self._desired_agent_links: list[Path] = []
+        self._desired_workspace_links: list[Path] = []
+
+    def build(self) -> SyncPlan:
+        self._plan_opencode_config()
+        self._plan_skills_links()
+        self._plan_agents_links()
+        self._plan_workspace_links()
+        self._plan_stale_cleanup()
+        return SyncPlan(actions=self.actions, errors=self.errors, skipped=self.skipped)
+
+    def _plan_opencode_config(self) -> None:
+        try:
+            mcp_base = self.common.load_mcp_base()
+            opencode_base = self.common.load_opencode_base()
+        except SyncAppError as exc:
+            self.errors.append(exc)
+            return
+        mapped_mcp = self.mapper.map_mcp_servers(mcp_base["mcpServers"])
+
+        existing_config, config_error = self.opencode.load_config_object()
+        if config_error is not None:
+            self.errors.append(config_error)
+            return
+
+        merged_config = self.opencode.merge_config(existing_config, opencode_base, mapped_mcp)
+        if same_json(self.opencode.config_path, merged_config):
+            self.actions.append(
+                Action(
+                    ActionKind.WRITE_JSON,
+                    self.opencode.config_path,
+                    ActionStatus.NOOP,
+                    "already in sync",
+                    payload=merged_config,
+                )
+            )
+            return
+
+        status = ActionStatus.CREATE if not self.opencode.config_path.exists() else ActionStatus.UPDATE
+        self.actions.append(
+            Action(
+                ActionKind.WRITE_JSON,
+                self.opencode.config_path,
+                status,
+                "merge opencode base + canonical mcp",
+                payload=merged_config,
+            )
+        )
+
+    def _plan_skills_links(self) -> None:
+        skill_sources = self.common.list_skill_sources()
+        mapped_skill_sources = [self.mapper.map_skill_source(source) for source in skill_sources]
+        self._desired_skill_links = [self.opencode.skills_dir / source.name for source in mapped_skill_sources]
+        for source in mapped_skill_sources:
+            action = self._plan_symlink(self.opencode.skills_dir / source.name, source)
+            self.actions.append(action)
+            if action.status == ActionStatus.CONFLICT:
+                self.skipped.append(f"Skill link skipped (conflict): {action.path}")
+
+    def _plan_agents_links(self) -> None:
+        agent_sources = self.common.list_agent_sources()
+        mapped_agent_sources = [self.mapper.map_agent_source(source) for source in agent_sources]
+        self._desired_agent_links = [self.opencode.agents_dir / source.name for source in mapped_agent_sources]
+        for source in mapped_agent_sources:
+            action = self._plan_symlink(self.opencode.agents_dir / source.name, source)
+            self.actions.append(action)
+            if action.status == ActionStatus.CONFLICT:
+                self.skipped.append(f"Agent link skipped (conflict): {action.path}")
+
+    def _plan_workspace_links(self) -> None:
+        for workspace in self.common.load_workspaces():
+            workspace_name = workspace["name"]
+            workspace_path = Path(workspace["path"])
+            if not workspace_path.exists() or not workspace_path.is_dir():
+                self.skipped.append(f"Workspace path missing, skipped: {workspace_name} ({workspace_path})")
+                continue
+
+            rules_file = self.workspace_service.resolve_rules_file(workspace_path)
+            if rules_file is None:
+                self.skipped.append(
+                    f"Workspace has no rules file ({WORKSPACE_RULE_FILES_DISPLAY}), skipped: {workspace_name}"
+                )
+                continue
+            mapped_rules_file = self.mapper.map_workspace_rules_source(rules_file)
+
+            for repo in self.workspace_service.discover_git_repos(workspace_path):
+                target = repo / AGENTS_FILENAME
+                action = self._plan_symlink(target, mapped_rules_file)
+                self.actions.append(action)
+                self._desired_workspace_links.append(target)
+                if action.status == ActionStatus.CONFLICT:
+                    self.skipped.append(f"Workspace rules link skipped (conflict): {target}")
+
+    def _plan_stale_cleanup(self) -> None:
+        state = self.common.load_state()
+        opencode_roots = [self.opencode.skills_dir.resolve(), self.opencode.agents_dir.resolve()]
+
+        self._plan_stale_group(
+            [Path(item) for item in state.get("managed_skill_links", []) if isinstance(item, str)],
+            self._desired_skill_links,
+            "remove stale managed skill symlink",
+            "stale managed path is not a symlink",
+            "stale symlink already absent",
+            "Stale link cleanup skipped (not symlink): {path}",
+            enforce_under_roots=opencode_roots,
+        )
+        self._plan_stale_group(
+            [Path(item) for item in state.get("managed_agent_links", []) if isinstance(item, str)],
+            self._desired_agent_links,
+            "remove stale managed agent symlink",
+            "stale managed path is not a symlink",
+            "stale symlink already absent",
+            "Stale link cleanup skipped (not symlink): {path}",
+            enforce_under_roots=opencode_roots,
+        )
+        self._plan_stale_group(
+            [Path(item) for item in state.get("managed_workspace_links", []) if isinstance(item, str)],
+            self._desired_workspace_links,
+            "remove stale managed workspace symlink",
+            "stale workspace path is not a symlink",
+            "stale workspace symlink already absent",
+            "Stale workspace cleanup skipped (not symlink): {path}",
+        )
+
+    def _plan_stale_group(
+        self,
+        old_links: list[Path],
+        desired_links: list[Path],
+        remove_detail: str,
+        conflict_detail: str,
+        noop_detail: str,
+        skipped_message: str,
+        enforce_under_roots: Optional[list[Path]] = None,
+    ) -> None:
+        desired = {str(path) for path in desired_links}
+        for old in old_links:
+            if str(old) in desired:
+                continue
+            if enforce_under_roots and not any(is_under(old, root) for root in enforce_under_roots):
+                continue
+            if old.is_symlink():
+                self.actions.append(Action(ActionKind.REMOVE_SYMLINK, old, ActionStatus.REMOVE, remove_detail))
+            elif old.exists():
+                self.actions.append(Action(ActionKind.REMOVE_SYMLINK, old, ActionStatus.CONFLICT, conflict_detail))
+                self.skipped.append(skipped_message.format(path=old))
+            else:
+                self.actions.append(Action(ActionKind.REMOVE_SYMLINK, old, ActionStatus.NOOP, noop_detail))
+
+    @staticmethod
+    def _plan_symlink(target: Path, source: Path) -> Action:
+        desired = _canonical_target(source)
+        if target.exists() or target.is_symlink():
+            if target.is_symlink():
+                current = os.path.realpath(target)
+                if current == desired:
+                    return Action(ActionKind.SYMLINK, target, ActionStatus.NOOP, "already linked", source=source)
+                return Action(ActionKind.SYMLINK, target, ActionStatus.FIX, "symlink points elsewhere", source=source)
+            return Action(ActionKind.SYMLINK, target, ActionStatus.CONFLICT, "non-symlink path exists", source=source)
+        return Action(ActionKind.SYMLINK, target, ActionStatus.CREATE, "create symlink", source=source)
+
+
+def build_plan(common: ISourceRepository, opencode: ITargetRepository, mapper: Optional[IConfigMapper] = None) -> SyncPlan:
+    return SyncPlanner(common=common, opencode=opencode, mapper=mapper).build()
+
+
+def filter_plan_for_target(plan: SyncPlan, target: str, opencode: ITargetRepository) -> SyncPlan:
+    try:
+        normalized_target = SyncTarget(target)
+    except ValueError:
+        return SyncPlan(actions=[], errors=plan.errors, skipped=plan.skipped)
+    return plan.filter_for_target(
+        target=normalized_target,
+        config_path=opencode.config_path,
+        skills_root=opencode.skills_dir,
+        agents_root=opencode.agents_dir,
+    )

code_agnostic/repositories/__init__.py

@@ -0,0 +1,13 @@
+from code_agnostic.repositories.base import IConfigRepository, ISourceRepository, ITargetRepository
+from code_agnostic.repositories.common import CommonRepository
+from code_agnostic.repositories.cursor import CursorRepository
+from code_agnostic.repositories.opencode import OpenCodeRepository
+
+__all__ = [
+    "IConfigRepository",
+    "ISourceRepository",
+    "ITargetRepository",
+    "CommonRepository",
+    "CursorRepository",
+    "OpenCodeRepository",
+]

code_agnostic/repositories/base.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+
+class IConfigRepository(ABC):
+    @property
+    @abstractmethod
+    def root(self) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_state(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def save_state(self, data: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+
+class ISourceRepository(IConfigRepository):
+    @property
+    @abstractmethod
+    def skills_dir(self) -> Path:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def agents_dir(self) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_mcp_base(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_opencode_base(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_skill_sources(self) -> list[Path]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_agent_sources(self) -> list[Path]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_workspaces(self) -> list[dict[str, str]]:
+        raise NotImplementedError
+
+
+class ITargetRepository(ABC):
+    @property
+    @abstractmethod
+    def root(self) -> Path:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def config_path(self) -> Path:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def skills_dir(self) -> Path:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def agents_dir(self) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_config_object(self) -> Tuple[dict[str, Any], Optional[Exception]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def merge_config(self, existing: dict[str, Any], base: dict[str, Any], mapped_mcp: dict[str, Any]) -> dict[str, Any]:
+        raise NotImplementedError

code_agnostic/repositories/common.py

@@ -0,0 +1,162 @@
+from pathlib import Path
+from typing import Any, Optional
+
+from code_agnostic.errors import InvalidConfigSchemaError, InvalidJsonFormatError, MissingConfigFileError
+from code_agnostic.repositories.base import ISourceRepository
+from code_agnostic.utils import read_json_safe, write_json
+
+
+class CommonRepository(ISourceRepository):
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self._root = root or (Path.home() / ".config" / "code-agnostic")
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    @property
+    def config_dir(self) -> Path:
+        return self.root / "config"
+
+    @property
+    def skills_dir(self) -> Path:
+        return self.root / "skills"
+
+    @property
+    def agents_dir(self) -> Path:
+        return self.root / "agents"
+
+    @property
+    def state_json(self) -> Path:
+        return self.root / ".sync-state.json"
+
+    @property
+    def mcp_base_path(self) -> Path:
+        return self.config_dir / "mcp.base.json"
+
+    @property
+    def opencode_base_path(self) -> Path:
+        return self.config_dir / "opencode.base.json"
+
+    @property
+    def workspaces_path(self) -> Path:
+        return self.config_dir / "workspaces.json"
+
+    def load_mcp_base(self) -> dict[str, Any]:
+        if not self.mcp_base_path.exists():
+            raise MissingConfigFileError(self.mcp_base_path)
+        payload, error = read_json_safe(self.mcp_base_path)
+        if error is not None:
+            raise InvalidJsonFormatError(self.mcp_base_path, error)
+        if not isinstance(payload, dict) or not isinstance(payload.get("mcpServers"), dict):
+            raise InvalidConfigSchemaError(self.mcp_base_path, "must contain object key 'mcpServers'")
+        return payload
+
+    def load_opencode_base(self) -> dict[str, Any]:
+        if not self.opencode_base_path.exists():
+            raise MissingConfigFileError(self.opencode_base_path)
+        payload, error = read_json_safe(self.opencode_base_path)
+        if error is not None:
+            raise InvalidJsonFormatError(self.opencode_base_path, error)
+        if not isinstance(payload, dict):
+            raise InvalidConfigSchemaError(self.opencode_base_path, "must be a JSON object")
+        return payload
+
+    def list_skill_sources(self) -> list[Path]:
+        if not self.skills_dir.exists():
+            return []
+        result: list[Path] = []
+        for child in sorted(self.skills_dir.iterdir()):
+            if child.is_dir() and (child / "SKILL.md").exists():
+                result.append(child)
+        return result
+
+    def list_agent_sources(self) -> list[Path]:
+        if not self.agents_dir.exists():
+            return []
+        result: list[Path] = []
+        for child in sorted(self.agents_dir.iterdir()):
+            if child.name.startswith("."):
+                continue
+            result.append(child)
+        return result
+
+    def load_state(self) -> dict[str, Any]:
+        payload, error = read_json_safe(self.state_json)
+        if error is not None or not isinstance(payload, dict):
+            return {
+                "managed_skill_links": [],
+                "managed_agent_links": [],
+                "managed_workspace_links": [],
+            }
+        payload.setdefault("managed_skill_links", [])
+        payload.setdefault("managed_agent_links", [])
+        payload.setdefault("managed_workspace_links", [])
+        if not isinstance(payload["managed_skill_links"], list):
+            payload["managed_skill_links"] = []
+        if not isinstance(payload["managed_agent_links"], list):
+            payload["managed_agent_links"] = []
+        if not isinstance(payload["managed_workspace_links"], list):
+            payload["managed_workspace_links"] = []
+        return payload
+
+    def save_state(self, data: dict[str, Any]) -> None:
+        write_json(self.state_json, data)
+
+    def load_workspaces(self) -> list[dict[str, str]]:
+        payload, error = read_json_safe(self.workspaces_path)
+        if error is not None or payload is None:
+            return []
+        if not isinstance(payload, list):
+            return []
+
+        result: list[dict[str, str]] = []
+        seen_names: set[str] = set()
+        for item in payload:
+            if not isinstance(item, dict):
+                continue
+            name = item.get("name")
+            path = item.get("path")
+            if not isinstance(name, str) or not isinstance(path, str):
+                continue
+            normalized_name = name.strip()
+            normalized_path = str(Path(path).expanduser().resolve())
+            if not normalized_name or normalized_name in seen_names:
+                continue
+            result.append({"name": normalized_name, "path": normalized_path})
+            seen_names.add(normalized_name)
+        return result
+
+    def save_workspaces(self, workspaces: list[dict[str, str]]) -> None:
+        serialized = sorted(
+            [{"name": item["name"], "path": item["path"]} for item in workspaces],
+            key=lambda item: item["name"].lower(),
+        )
+        write_json(self.workspaces_path, serialized)
+
+    def add_workspace(self, name: str, path: Path) -> None:
+        normalized_name = name.strip()
+        if not normalized_name:
+            raise ValueError("Workspace name cannot be empty")
+        normalized_path = path.expanduser().resolve()
+        if not normalized_path.exists() or not normalized_path.is_dir():
+            raise ValueError(f"Workspace path does not exist or is not a directory: {normalized_path}")
+
+        workspaces = self.load_workspaces()
+        for item in workspaces:
+            if item["name"] == normalized_name:
+                raise ValueError(f"Workspace name already exists: {normalized_name}")
+            if Path(item["path"]) == normalized_path:
+                raise ValueError(f"Workspace path already exists: {normalized_path}")
+
+        workspaces.append({"name": normalized_name, "path": str(normalized_path)})
+        self.save_workspaces(workspaces)
+
+    def remove_workspace(self, name: str) -> bool:
+        target_name = name.strip()
+        workspaces = self.load_workspaces()
+        kept = [item for item in workspaces if item["name"] != target_name]
+        if len(kept) == len(workspaces):
+            return False
+        self.save_workspaces(kept)
+        return True

code_agnostic/repositories/cursor.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+from typing import Optional
+
+
+class CursorRepository:
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self._root = root or (Path.home() / ".cursor")
+
+    @property
+    def root(self) -> Path:
+        return self._root