code-agnostic 0.3.18__tar.gz → 0.5.0__tar.gz

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.3.18
+Version: 0.5.0
 Summary: Centralized hub for LLM coding config: MCP, skills, rules, and agents.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.18"
+__version__ = "0.5.0"

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/agents/claude.py

@@ -6,7 +6,7 @@ import re
 from pathlib import Path
 from typing import Any
 
-import yaml  # type: ignore[import-untyped]
+import yaml
 
 from code_agnostic.agents.models import Agent
 

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/agents/codex.py

@@ -7,9 +7,9 @@ from pathlib import Path
 from typing import Any
 
 try:
-    import tomllib
+    import tomllib  # type: ignore[import-not-found]
 except ModuleNotFoundError:  # pragma: no cover
-    import tomli as tomllib  # type: ignore
+    import tomli as tomllib
 
 import tomlkit
 

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/agents/parser.py

@@ -83,7 +83,7 @@ def parse_agent(path: Path) -> Agent:
 
 
 def serialize_agent(agent: Agent, *, target_app: str | None = None) -> str:
-    fm: dict = {}
+    fm: dict[str, Any] = {}
     if agent.metadata.name:
         fm["name"] = agent.metadata.name
     if agent.metadata.description:
@@ -105,7 +105,7 @@ def serialize_agent(agent: Agent, *, target_app: str | None = None) -> str:
     if nickname_candidates:
         fm["nickname_candidates"] = list(nickname_candidates)
 
-    tools: dict = {}
+    tools: dict[str, Any] = {}
     if agent.metadata.tools.read is not True:
         tools["read"] = agent.metadata.tools.read
     if agent.metadata.tools.write is not True:

code_agnostic-0.5.0/code_agnostic/apps/apps_service.py

@@ -0,0 +1,294 @@
+from pathlib import Path
+from typing import Any
+
+from code_agnostic.apps.app_id import AppId, app_ids_by_capability, app_scope
+from code_agnostic.apps.common.framework import (
+    create_registered_app_service,
+    list_registered_app_services,
+)
+from code_agnostic.apps.common.interfaces.service import IAppConfigService
+from code_agnostic.apps.common.symlink_planning import (
+    load_state_links,
+    load_state_paths,
+    plan_stale_files_group,
+    plan_stale_group,
+)
+from code_agnostic.core.project_repository import ProjectConfigRepository
+from code_agnostic.core.repository import CoreRepository
+from code_agnostic.core.workspace_repository import WorkspaceConfigRepository
+from code_agnostic.executor import SyncExecutor
+from code_agnostic.models import Action, AppStatusRow, AppSyncStatus, SyncPlan
+from code_agnostic.planner import SyncPlanner
+from code_agnostic.project_artifacts import load_project_entries, project_config_dir
+from code_agnostic.utils import read_json_safe, write_json
+
+
+class AppsService:
+    def __init__(self, core_repository: CoreRepository) -> None:
+        self.core_repository = core_repository
+
+    @property
+    def apps_path(self) -> Path:
+        return self.core_repository.root / "config" / "apps.json"
+
+    def available_apps(self) -> list[str]:
+        registered = set(list_registered_app_services())
+        manageable = set(app_ids_by_capability(toggleable=True))
+        return [
+            app.value
+            for app in sorted(registered & manageable, key=lambda item: item.value)
+        ]
+
+    def load_apps(self) -> dict[str, bool]:
+        payload, error = read_json_safe(self.apps_path)
+        if error is not None or not isinstance(payload, dict):
+            return self._default_apps()
+
+        result = self._default_apps()
+        for app_name in self.available_apps():
+            value = payload.get(app_name)
+            if isinstance(value, bool):
+                result[app_name] = value
+        return result
+
+    def save_apps(self, apps: dict[str, bool]) -> None:
+        normalized = self._default_apps()
+        for app_name in self.available_apps():
+            value = apps.get(app_name)
+            if isinstance(value, bool):
+                normalized[app_name] = value
+        write_json(self.apps_path, normalized)
+
+    def is_enabled(self, app_name: str) -> bool:
+        return self.load_apps().get(app_name, False)
+
+    def set_enabled(self, app_name: str, enabled: bool) -> None:
+        if app_name not in self.available_apps():
+            raise ValueError(f"Unknown app: {app_name}")
+        apps = self.load_apps()
+        apps[app_name] = enabled
+        self.save_apps(apps)
+
+    def enable(self, app_name: str) -> None:
+        self.set_enabled(app_name=app_name, enabled=True)
+
+    def disable(self, app_name: str) -> tuple[int, int, list[str]]:
+        """Disable an app AND clean up everything it previously synced.
+
+        Removes tracked skills/agents/compiled files and prunes the MCP servers
+        we own from the app's shared config, across global, workspace, and
+        project scopes, then clears the corresponding state. Without this,
+        disabling would strand orphaned artifacts with no way to reclaim them.
+        """
+        normalized = app_name.lower()
+        plan = self._plan_app_cleanup(normalized)
+        result: tuple[int, int, list[str]] = (0, 0, [])
+        if plan.actions:
+            result = SyncExecutor(core=self.core_repository).execute(
+                plan, persist_state=True
+            )
+        self.set_enabled(app_name=normalized, enabled=False)
+        return result
+
+    def _plan_app_cleanup(self, app_name: str) -> SyncPlan:
+        try:
+            app_id = AppId(app_name)
+        except ValueError:
+            return SyncPlan([], [], [])
+
+        actions: list[Action] = []
+        skipped: list[str] = []
+        core = self.core_repository
+
+        # --- Global scopes (app:<app>:*) ---
+        global_state = core.load_state()
+        global_links = self._normalize_group(global_state.get("managed_links"))
+        global_paths = self._normalize_group(global_state.get("managed_paths"))
+        global_mcp = self._normalize_group(global_state.get("managed_mcp"))
+        global_prefix = f"app:{app_id.value}:"
+        for scope in sorted(s for s in global_links if s.startswith(global_prefix)):
+            actions.extend(self._cleanup_links(global_links, scope, app_id.value))
+        for scope in sorted(s for s in global_paths if s.startswith(global_prefix)):
+            actions.extend(
+                self._cleanup_paths(global_paths, scope, app_id.value, skipped)
+            )
+        actions.extend(self._cleanup_global_mcp(app_id, global_mcp))
+
+        # --- Workspace scopes (ws:<app>:*) ---
+        ws_prefix = f"ws:{app_id.value}:"
+        for workspace in core.load_workspaces():
+            ws_name = workspace["name"]
+            ws_repo = WorkspaceConfigRepository(root=core.workspace_config_dir(ws_name))
+            ws_state = ws_repo.load_state()
+            ws_links = self._normalize_group(ws_state.get("managed_links"))
+            ws_paths = self._normalize_group(ws_state.get("managed_paths"))
+            for scope in sorted(s for s in ws_links if s.startswith(ws_prefix)):
+                for action in self._cleanup_links(ws_links, scope, "workspace"):
+                    action.workspace = ws_name
+                    actions.append(action)
+            for scope in sorted(s for s in ws_paths if s.startswith(ws_prefix)):
+                for action in self._cleanup_paths(
+                    ws_paths, scope, "workspace", skipped
+                ):
+                    action.workspace = ws_name
+                    actions.append(action)
+
+        # --- Project scopes (project:<app>:*) ---
+        project_prefix = f"project:{app_id.value}:"
+        for project in load_project_entries(core):
+            project_name = project["name"]
+            project_repo = ProjectConfigRepository(
+                root=project_config_dir(core, project_name)
+            )
+            project_state = project_repo.load_state()
+            project_links = self._normalize_group(project_state.get("managed_links"))
+            project_paths = self._normalize_group(project_state.get("managed_paths"))
+            for scope in sorted(
+                s for s in project_links if s.startswith(project_prefix)
+            ):
+                for action in self._cleanup_links(project_links, scope, app_id.value):
+                    action.project = project_name
+                    actions.append(action)
+            for scope in sorted(
+                s for s in project_paths if s.startswith(project_prefix)
+            ):
+                for action in self._cleanup_paths(
+                    project_paths, scope, app_id.value, skipped
+                ):
+                    action.project = project_name
+                    actions.append(action)
+
+        return SyncPlan(actions=actions, errors=[], skipped=skipped)
+
+    @staticmethod
+    def _normalize_group(value: Any) -> dict[str, Any]:
+        return (
+            {scope: paths for scope, paths in value.items() if isinstance(scope, str)}
+            if isinstance(value, dict)
+            else {}
+        )
+
+    @staticmethod
+    def _cleanup_links(group: dict[str, Any], scope: str, app: str) -> list[Action]:
+        return plan_stale_group(
+            old_links=load_state_links(group, scope),
+            desired_links=[],
+            remove_detail=f"remove {scope} symlink on disable",
+            conflict_detail="managed path is not a symlink",
+            noop_detail="managed symlink already absent",
+            app=app,
+            scope=scope,
+            skipped=[],
+            skipped_message="Disable cleanup skipped (not symlink): {path}",
+        )
+
+    @staticmethod
+    def _cleanup_paths(
+        group: dict[str, Any], scope: str, app: str, skipped: list[str]
+    ) -> list[Action]:
+        return plan_stale_files_group(
+            old_paths=load_state_paths(group, scope),
+            desired_paths=[],
+            remove_detail=f"remove {scope} file on disable",
+            conflict_detail="managed path is not a file",
+            noop_detail="managed file already absent",
+            app=app,
+            scope=scope,
+            skipped=skipped,
+            skipped_message="Disable cleanup skipped (not file): {path}",
+        )
+
+    def _cleanup_global_mcp(
+        self, app_id: AppId, managed_mcp: dict[str, Any]
+    ) -> list[Action]:
+        scope = app_scope(app_id, "mcp")
+        raw = managed_mcp.get(scope, [])
+        managed = (
+            {item for item in raw if isinstance(item, str)}
+            if isinstance(raw, list)
+            else set()
+        )
+        if not managed:
+            return []
+        try:
+            service = create_registered_app_service(app_id)
+        except (KeyError, ValueError):
+            return []
+        if not service.repository.config_path.exists():
+            return []
+        # Empty desired + our previously-managed names → prune only our servers,
+        # keep the user's, and clear managed_mcp state (mcp_managed becomes []).
+        return [service.build_action({}, previously_managed=managed)]
+
+    def list_status_rows(self) -> list[AppStatusRow]:
+        apps = self.load_apps()
+        rows: list[AppStatusRow] = []
+        for app_name in self.available_apps():
+            enabled = apps.get(app_name, False)
+            detail = "enabled by user" if enabled else "disabled by default"
+            rows.append(
+                AppStatusRow(
+                    name=app_name,
+                    status=AppSyncStatus.ENABLED if enabled else AppSyncStatus.DISABLED,
+                    detail=detail,
+                )
+            )
+        return rows
+
+    def enabled_apps(self) -> list[str]:
+        apps = self.load_apps()
+        return [name for name in self.available_apps() if apps.get(name, False)]
+
+    def plan_for_target(self, target: str, *, apply_excludes: bool = False) -> SyncPlan:
+        normalized = target.lower()
+        if normalized != "all" and not self.is_enabled(normalized):
+            return SyncPlan([], [], [f"{normalized} is disabled for sync."])
+
+        app_services = self._resolve_services_for_target(normalized)
+        plan = SyncPlanner(
+            core=self.core_repository,
+            app_services=app_services,
+            include_workspace=True,
+            include_git_excludes=apply_excludes,
+        ).build()
+        if normalized == "all":
+            if (
+                not app_services
+                and not plan.actions
+                and not plan.errors
+                and not plan.skipped
+            ):
+                return SyncPlan([], [], ["No apps enabled for sync."])
+            return plan
+        return plan.filter_for_target(normalized)
+
+    def execute_plan(self, scoped_plan: SyncPlan) -> tuple[int, int, list[str]]:
+        persist_state = self._requires_state_persist(scoped_plan)
+        return SyncExecutor(core=self.core_repository).execute(
+            scoped_plan, persist_state=persist_state
+        )
+
+    def _resolve_services_for_target(self, target: str) -> list[IAppConfigService]:
+        enabled = set(self.enabled_apps())
+        if target == "all":
+            selected = enabled
+        else:
+            selected = {target} if target in enabled else set()
+
+        services: list[IAppConfigService] = []
+        for app in sorted(selected):
+            try:
+                services.append(create_registered_app_service(AppId(app)))
+            except (KeyError, ValueError):
+                continue
+        return services
+
+    @staticmethod
+    def _requires_state_persist(scoped_plan: SyncPlan) -> bool:
+        return any(
+            action.kind.value in ("symlink", "remove_symlink") or action.app is not None
+            for action in scoped_plan.actions
+        )
+
+    def _default_apps(self) -> dict[str, bool]:
+        return {name: False for name in self.available_apps()}

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/claude/service.py

@@ -53,6 +53,10 @@ class ClaudeConfigService(RegisteredAppConfigService):
     def mapper(self) -> IAppMCPMapper:
         return self._mapper
 
+    @property
+    def mcp_config_key(self) -> str:
+        return "mcpServers"
+
     def validate_config(self, payload: Any) -> None:
         if not isinstance(payload, dict):
             raise InvalidConfigSchemaError(
@@ -62,16 +66,6 @@ class ClaudeConfigService(RegisteredAppConfigService):
     def build_action_payload(self, payload: dict[str, Any]) -> Any:
         return payload
 
-    def set_mcp_payload(
-        self, merged: dict[str, Any], desired_mcp: dict[str, Any]
-    ) -> None:
-        existing_mcp = merged.get("mcpServers")
-        preserved = deepcopy(existing_mcp) if isinstance(existing_mcp, dict) else {}
-        for name, config in desired_mcp.items():
-            preserved[name] = deepcopy(config)
-        if preserved:
-            merged["mcpServers"] = preserved
-
     def derive_status(
         self, existing: dict[str, Any], merged: dict[str, Any]
     ) -> ActionStatus:

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/codex/config_repository.py

@@ -3,9 +3,9 @@ from pathlib import Path
 from typing import Any
 
 try:
-    import tomllib
+    import tomllib  # type: ignore[import-not-found]
 except ModuleNotFoundError:  # pragma: no cover
-    import tomli as tomllib  # type: ignore
+    import tomli as tomllib
 
 import tomlkit
 

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/codex/service.py

@@ -7,7 +7,7 @@ from jsonschema import Draft7Validator
 from code_agnostic.agents.codex import normalize_codex_agent_filename
 from code_agnostic.agents.compilers import CodexAgentCompiler
 from code_agnostic.agents.parser import parse_agent
-from code_agnostic.apps.app_id import AppId, app_label
+from code_agnostic.apps.app_id import AppId, app_label, app_scope
 from code_agnostic.apps.common.framework import (
     RegisteredAppConfigService,
     format_schema_error,
@@ -84,6 +84,10 @@ class CodexConfigService(RegisteredAppConfigService):
     def mapper(self) -> IAppMCPMapper:
         return self._mapper
 
+    @property
+    def mcp_config_key(self) -> str:
+        return "mcp_servers"
+
     def validate_config(self, payload: Any) -> None:
         error = next(iter(self._validator.iter_errors(payload)), None)
         if error is not None:
@@ -94,18 +98,6 @@ class CodexConfigService(RegisteredAppConfigService):
     def build_action_payload(self, payload: dict[str, Any]) -> Any:
         return self.repository.serialize_config(payload)
 
-    def set_mcp_payload(
-        self, merged: dict[str, Any], desired_mcp: dict[str, Any]
-    ) -> None:
-        existing_mcp = merged.get("mcp_servers")
-        preserved = dict(existing_mcp) if isinstance(existing_mcp, dict) else {}
-        for name, config in desired_mcp.items():
-            preserved[name] = deepcopy(config)
-        if preserved:
-            merged["mcp_servers"] = preserved
-        else:
-            merged.pop("mcp_servers", None)
-
     def derive_status(
         self, existing: dict[str, Any], merged: dict[str, Any]
     ) -> ActionStatus:
@@ -125,6 +117,9 @@ class CodexConfigService(RegisteredAppConfigService):
         self,
         common_servers: dict[str, MCPServerDTO],
         agent_sources: list[Path] | None = None,
+        previously_managed: set[str] | None = None,
+        *,
+        replace_mcp: bool = False,
     ) -> Action:
         existing = self._codex_repo.load_config()
         if existing or self._codex_repo.config_path.exists():
@@ -146,7 +141,9 @@ class CodexConfigService(RegisteredAppConfigService):
                 merged[key] = merge_dict_overlay(current, value)
                 continue
             merged[key] = deepcopy(value)
-        self.set_mcp_payload(merged, desired_mcp)
+        self.set_mcp_payload(
+            merged, desired_mcp, previously_managed, replace=replace_mcp
+        )
         if agent_sources:
             merged["agents"] = self._merge_agents_payload(
                 merged.get("agents"),
@@ -154,7 +151,7 @@ class CodexConfigService(RegisteredAppConfigService):
             )
         self.validate_config(merged)
 
-        return Action(
+        action = Action(
             kind=self.action_kind,
             path=self.repository.config_path,
             status=self.derive_status(existing, merged),
@@ -162,6 +159,10 @@ class CodexConfigService(RegisteredAppConfigService):
             payload=self.build_action_payload(merged),
             app=self.app_id.value,
         )
+        if not replace_mcp:
+            action.scope = app_scope(self.app_id, "mcp")
+            action.mcp_managed = sorted(desired_mcp)
+        return action
 
     def _merge_agents_payload(
         self, existing: Any, overlay: dict[str, Any]

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/common/framework.py

@@ -20,12 +20,12 @@ class AppServiceRegistryMeta(ABCMeta):
         bases: tuple[type, ...],
         namespace: dict[str, Any],
         **kwargs: Any,
-    ):
+    ) -> "AppServiceRegistryMeta":
         cls = super().__new__(mcls, name, bases, namespace, **kwargs)
         app_id = getattr(cls, "APP_ID", None)
         is_abstract = bool(getattr(cls, "__abstractmethods__", False))
         if app_id is not None and not is_abstract:
-            mcls._registry[app_id] = cast(type["RegisteredAppConfigService"], cls)  # type: ignore[assignment]
+            mcls._registry[app_id] = cast(type["RegisteredAppConfigService"], cls)
         return cls
 
 

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/common/interfaces/service.py

@@ -11,6 +11,7 @@ from code_agnostic.apps.common.interfaces.mapper import IAppMCPMapper
 from code_agnostic.apps.common.interfaces.repositories import IAppConfigRepository
 from code_agnostic.apps.common.interfaces.repositories import ISourceRepository
 from code_agnostic.apps.common.models import MCPServerDTO
+from code_agnostic.apps.common.utils import apply_mcp_servers
 from code_agnostic.apps.common.symlink_planning import (
     load_state_links,
     load_state_paths,
@@ -52,6 +53,12 @@ class IAppConfigService(ABC):
     def mapper(self) -> IAppMCPMapper:
         raise NotImplementedError
 
+    @property
+    @abstractmethod
+    def mcp_config_key(self) -> str:
+        """Native config key that holds the MCP server map for this editor."""
+        raise NotImplementedError
+
     @abstractmethod
     def validate_config(self, payload: Any) -> None:
         raise NotImplementedError
@@ -60,11 +67,21 @@ class IAppConfigService(ABC):
     def build_action_payload(self, payload: dict[str, Any]) -> Any:
         raise NotImplementedError
 
-    @abstractmethod
     def set_mcp_payload(
-        self, merged: dict[str, Any], desired_mcp: dict[str, Any]
+        self,
+        merged: dict[str, Any],
+        desired_mcp: dict[str, Any],
+        previously_managed: set[str] | None = None,
+        *,
+        replace: bool = False,
     ) -> None:
-        raise NotImplementedError
+        result = apply_mcp_servers(
+            merged.get(self.mcp_config_key),
+            desired_mcp,
+            previously_managed,
+            replace=replace,
+        )
+        merged[self.mcp_config_key] = result
 
     @abstractmethod
     def derive_status(
@@ -236,6 +253,9 @@ class IAppConfigService(ABC):
         self,
         common_servers: dict[str, MCPServerDTO],
         agent_sources: list[Path] | None = None,
+        previously_managed: set[str] | None = None,
+        *,
+        replace_mcp: bool = False,
     ) -> Action:
         existing = self.repository.load_config()
         if existing or self.repository.config_path.exists():
@@ -243,10 +263,12 @@ class IAppConfigService(ABC):
 
         desired_mcp = self.mapper.from_common(common_servers)
         merged = dict(existing)
-        self.set_mcp_payload(merged, desired_mcp)
+        self.set_mcp_payload(
+            merged, desired_mcp, previously_managed, replace=replace_mcp
+        )
         self.validate_config(merged)
 
-        return Action(
+        action = Action(
             kind=self.action_kind,
             path=self.repository.config_path,
             status=self.derive_status(existing, merged),
@@ -254,6 +276,12 @@ class IAppConfigService(ABC):
             payload=self.build_action_payload(merged),
             app=self.app_id.value,
         )
+        if not replace_mcp:
+            # User-shared global config: track which servers we own so a later
+            # source removal can be pruned without touching the user's servers.
+            action.scope = app_scope(self.app_id, "mcp")
+            action.mcp_managed = sorted(desired_mcp)
+        return action
 
     def build_plan(
         self,
@@ -263,8 +291,12 @@ class IAppConfigService(ABC):
         state = source_repository.load_state()
         managed_links_group = self._normalize_managed_group(state.get("managed_links"))
         managed_paths_group = self._normalize_managed_group(state.get("managed_paths"))
+        managed_mcp_group = self._normalize_managed_group(state.get("managed_mcp"))
         skill_scope = app_scope(self.app_id, "skills")
         agent_scope = app_scope(self.app_id, "agents")
+        previously_managed_mcp = self._load_state_names(
+            managed_mcp_group, app_scope(self.app_id, "mcp")
+        )
 
         skill_actions, skill_skipped = self._build_compiled_group(
             sources=source_repository.list_skill_sources(),
@@ -292,6 +324,7 @@ class IAppConfigService(ABC):
                 self.build_action(
                     common_servers,
                     agent_sources=source_repository.list_agent_sources(),
+                    previously_managed=previously_managed_mcp,
                 ),
                 *skill_actions,
                 *agent_actions,
@@ -299,3 +332,10 @@ class IAppConfigService(ABC):
             errors=[],
             skipped=[*skill_skipped, *agent_skipped],
         )
+
+    @staticmethod
+    def _load_state_names(group: dict[str, Any], scope: str) -> set[str]:
+        raw = group.get(scope, [])
+        if not isinstance(raw, list):
+            return set()
+        return {item for item in raw if isinstance(item, str)}

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/common/schema.py

@@ -51,6 +51,6 @@ class JsonSchemaRepository(ISchemaRepository):
         now = time.time()
         if cached and now - cached[0] < self.ttl_seconds:
             return cached[1]
-        schema = json.loads(path.read_text(encoding="utf-8"))
+        schema: dict[str, Any] = json.loads(path.read_text(encoding="utf-8"))
         _SCHEMA_CACHE[key] = (now, schema)
         return schema

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/common/utils.py

@@ -1,3 +1,5 @@
+from collections.abc import Iterable
+from copy import deepcopy
 from typing import Any
 
 from code_agnostic.apps.app_id import AppId, app_ids_by_capability
@@ -30,6 +32,40 @@ def _split_app_targeted_key(key: str) -> tuple[str, str, str] | None:
     return marker, app_name, server_name
 
 
+def apply_mcp_servers(
+    existing: Any,
+    desired: dict[str, Any],
+    previously_managed: Iterable[str] | None = None,
+    *,
+    replace: bool = False,
+) -> dict[str, Any]:
+    """Merge desired MCP servers into an existing native MCP map.
+
+    Two ownership models:
+
+    - ``replace=True`` — the target file is fully owned/generated by this tool
+      (workspace/project outputs). The result is exactly ``desired``; anything
+      else that was there is dropped.
+    - ``replace=False`` (default) — the target is a user-shared config
+      (``~/.codex``, ``~/.claude.json``, ``~/.cursor/mcp.json`` …). Servers the
+      user added by hand are preserved; servers we previously wrote
+      (``previously_managed``) that are no longer desired are pruned; desired
+      servers are upserted. This is ownership-aware cleanup: our orphans go, the
+      user's stay.
+    """
+
+    if replace:
+        return {name: deepcopy(config) for name, config in desired.items()}
+
+    result: dict[str, Any] = deepcopy(existing) if isinstance(existing, dict) else {}
+    for name in previously_managed or ():
+        if name not in desired:
+            result.pop(name, None)
+    for name, config in desired.items():
+        result[name] = deepcopy(config)
+    return result
+
+
 def mcp_servers_for_app(
     mcp_servers: dict[str, Any], app_id: AppId | str
 ) -> dict[str, Any]:

{code_agnostic-0.3.18 → code_agnostic-0.5.0}/code_agnostic/apps/copilot/service.py

@@ -51,6 +51,10 @@ class CopilotConfigService(RegisteredAppConfigService):
     def mapper(self) -> IAppMCPMapper:
         return self._mapper
 
+    @property
+    def mcp_config_key(self) -> str:
+        return "mcpServers"
+
     def validate_config(self, payload: Any) -> None:
         if not isinstance(payload, dict):
             raise InvalidConfigSchemaError(
@@ -65,11 +69,6 @@ class CopilotConfigService(RegisteredAppConfigService):
     def build_action_payload(self, payload: dict[str, Any]) -> Any:
         return payload
 
-    def set_mcp_payload(
-        self, merged: dict[str, Any], desired_mcp: dict[str, Any]
-    ) -> None:
-        merged["mcpServers"] = desired_mcp
-
     def derive_status(
         self, existing: dict[str, Any], merged: dict[str, Any]
     ) -> ActionStatus: