code-agnostic 0.6.0__tar.gz → 0.8.0__tar.gz

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.6.0
+Version: 0.8.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.6.0 → code_agnostic-0.8.0}/code_agnostic/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.6.0"
+__version__ = "0.8.0"

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/apps/apps_service.py

@@ -6,6 +6,7 @@ from code_agnostic.apps.common.framework import (
     create_registered_app_service,
     list_registered_app_services,
 )
+from code_agnostic.apps.claude.service import ClaudeConfigService
 from code_agnostic.apps.common.interfaces.service import IAppConfigService
 from code_agnostic.apps.common.symlink_planning import (
     load_state_links,
@@ -102,9 +103,9 @@ class AppsService:
 
         # --- 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_links = global_state.managed_links
+        global_paths = global_state.managed_paths
+        global_mcp = global_state.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))
@@ -113,6 +114,8 @@ class AppsService:
                 self._cleanup_paths(global_paths, scope, app_id.value, skipped)
             )
         actions.extend(self._cleanup_global_mcp(app_id, global_mcp))
+        if app_id == AppId.CLAUDE:
+            actions.extend(self._cleanup_claude_projects(global_mcp))
 
         # --- Workspace scopes (ws:<app>:*) ---
         ws_prefix = f"ws:{app_id.value}:"
@@ -120,8 +123,8 @@ class AppsService:
             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"))
+            ws_links = ws_state.managed_links
+            ws_paths = ws_state.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
@@ -141,8 +144,8 @@ class AppsService:
                 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"))
+            project_links = project_state.managed_links
+            project_paths = project_state.managed_paths
             for scope in sorted(
                 s for s in project_links if s.startswith(project_prefix)
             ):
@@ -160,14 +163,6 @@ class AppsService:
 
         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(
@@ -224,6 +219,27 @@ class AppsService:
             )
         ]
 
+    def _cleanup_claude_projects(self, managed_mcp: dict[str, Any]) -> list[Action]:
+        managed = self._names_for_scope(
+            managed_mcp, app_scope(AppId.CLAUDE, "projects")
+        )
+        if not managed:
+            return []
+        try:
+            service = create_registered_app_service(AppId.CLAUDE)
+        except (KeyError, ValueError):
+            return []
+        if not isinstance(service, ClaudeConfigService):
+            return []
+        if not service.repository.config_path.exists():
+            return []
+        # Empty desired + our previously-managed project paths → prune only the
+        # `mcpServers` sub-keys we wrote, keep the rest of each project entry, and
+        # clear the ownership state (managed_entries becomes empty).
+        return [
+            service.build_project_mcp_action({}, previously_managed_projects=managed)
+        ]
+
     @staticmethod
     def _names_for_scope(group: dict[str, Any], scope: str) -> set[str]:
         raw = group.get(scope, [])

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/apps/claude/service.py

@@ -5,7 +5,7 @@ from typing import Any
 from code_agnostic.agents.claude import claude_agent_target_path
 from code_agnostic.agents.compilers import ClaudeAgentCompiler
 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.claude.config_repository import ClaudeConfigRepository
 from code_agnostic.apps.claude.mapper import ClaudeMCPMapper
 from code_agnostic.apps.common.framework import RegisteredAppConfigService
@@ -72,6 +72,7 @@ class ClaudeConfigService(RegisteredAppConfigService):
         self,
         project_servers: dict[Path, dict[str, MCPServerDTO]],
         base_payload: dict[str, Any] | None = None,
+        previously_managed_projects: set[str] | None = None,
     ) -> Action:
         existing = self._repository.load_config()
         if existing or self.repository.config_path.exists():
@@ -86,8 +87,10 @@ class ClaudeConfigService(RegisteredAppConfigService):
         else:
             projects = deepcopy(projects)
 
+        desired_keys: set[str] = set()
         for project_path, servers in project_servers.items():
             key = str(project_path.resolve())
+            desired_keys.add(key)
             project = projects.get(key)
             if not isinstance(project, dict):
                 project = {}
@@ -96,10 +99,18 @@ class ClaudeConfigService(RegisteredAppConfigService):
             project["mcpServers"] = self.mapper.from_common(servers)
             projects[key] = project
 
+        # Prune the `mcpServers` sub-key from project entries we previously wrote
+        # but no longer sync (e.g. a repo removed from a workspace). Leave the rest
+        # of the project entry (history etc.) and non-managed projects untouched.
+        for stale_key in (previously_managed_projects or set()) - desired_keys:
+            stale_project = projects.get(stale_key)
+            if isinstance(stale_project, dict):
+                stale_project.pop("mcpServers", None)
+
         merged["projects"] = projects
         self.validate_config(merged)
 
-        return Action(
+        action = Action(
             kind=self.action_kind,
             path=self.repository.config_path,
             status=self.derive_status(existing, merged),
@@ -107,6 +118,12 @@ class ClaudeConfigService(RegisteredAppConfigService):
             payload=merged,
             app=self.app_id.value,
         )
+        # Track which project paths we own so a later source removal prunes only
+        # our `mcpServers` sub-keys without touching the user's project entries.
+        projects_scope = app_scope(self.app_id, "projects")
+        action.scope = projects_scope
+        action.managed_entries = {projects_scope: sorted(desired_keys)}
+        return action
 
     def plan_skill_actions(
         self,

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/apps/common/interfaces/repositories.py

@@ -2,6 +2,8 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any
 
+from code_agnostic.models import SyncState
+
 
 class ISchemaRepository(ABC):
     @abstractmethod
@@ -59,7 +61,7 @@ class IConfigRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def load_state(self) -> dict[str, Any]:
+    def load_state(self) -> SyncState:
         raise NotImplementedError
 
     @abstractmethod

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/apps/common/interfaces/service.py

@@ -135,10 +135,6 @@ class IAppConfigService(ABC):
     def compiled_resource_ownership_policy(self) -> OwnershipPolicy:
         return OwnershipPolicy.OWNED_ONLY
 
-    @staticmethod
-    def _normalize_managed_group(value: Any) -> dict[str, Any]:
-        return value if isinstance(value, dict) else {}
-
     def _plan_compiled_text_actions(
         self,
         *,
@@ -308,9 +304,9 @@ class IAppConfigService(ABC):
         source_repository: ISourceRepository,
     ) -> SyncPlan:
         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"))
+        managed_links_group = state.managed_links
+        managed_paths_group = state.managed_paths
+        managed_mcp_group = state.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(

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/core/repository.py

@@ -10,6 +10,7 @@ from code_agnostic.errors import (
     InvalidJsonFormatError,
     MissingConfigFileError,
 )
+from code_agnostic.models import SyncState
 from code_agnostic.spec.loaders import (
     load_mcp_base as load_mcp_bundle,
     validate_schema_payload,
@@ -110,36 +111,11 @@ class BaseSourceRepository(ISourceRepository):
                 result.append(child)
         return result
 
-    def load_state(self) -> dict[str, Any]:
+    def load_state(self) -> SyncState:
         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": [],
-                "managed_links": {},
-                "managed_paths": {},
-                "managed_mcp": {},
-            }
-        payload.setdefault("managed_skill_links", [])
-        payload.setdefault("managed_agent_links", [])
-        payload.setdefault("managed_workspace_links", [])
-        payload.setdefault("managed_links", {})
-        payload.setdefault("managed_paths", {})
-        payload.setdefault("managed_mcp", {})
-        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"] = []
-        if not isinstance(payload["managed_links"], dict):
-            payload["managed_links"] = {}
-        if not isinstance(payload["managed_paths"], dict):
-            payload["managed_paths"] = {}
-        if not isinstance(payload["managed_mcp"], dict):
-            payload["managed_mcp"] = {}
-        return payload
+        if error is not None:
+            return SyncState()
+        return SyncState.from_payload(payload)
 
     def save_state(self, data: dict[str, Any]) -> None:
         write_json(self.state_json, data)

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/executor.py

@@ -830,17 +830,17 @@ class SyncExecutor:
             global_state = {
                 "updated_at": updated_at,
                 "managed_links": self._merge_managed_links(
-                    existing=existing_global_state.get("managed_links"),
+                    existing=existing_global_state.managed_links,
                     touched_scopes=global_touched_scopes,
                     current_links=global_links,
                 ),
                 "managed_paths": self._merge_managed_links(
-                    existing=existing_global_state.get("managed_paths"),
+                    existing=existing_global_state.managed_paths,
                     touched_scopes=global_touched_scopes,
                     current_links=global_paths,
                 ),
                 "managed_mcp": self._merge_managed_links(
-                    existing=existing_global_state.get("managed_mcp"),
+                    existing=existing_global_state.managed_mcp,
                     touched_scopes=global_mcp_touched,
                     current_links=global_mcp,
                 ),
@@ -863,12 +863,12 @@ class SyncExecutor:
             ws_state = {
                 "updated_at": updated_at,
                 "managed_links": self._merge_managed_links(
-                    existing=existing_workspace_state.get("managed_links"),
+                    existing=existing_workspace_state.managed_links,
                     touched_scopes=workspace_touched_scopes[ws_name],
                     current_links=workspace_links.get(ws_name, {}),
                 ),
                 "managed_paths": self._merge_managed_links(
-                    existing=existing_workspace_state.get("managed_paths"),
+                    existing=existing_workspace_state.managed_paths,
                     touched_scopes=workspace_touched_scopes[ws_name],
                     current_links=workspace_paths.get(ws_name, {}),
                 ),
@@ -893,12 +893,12 @@ class SyncExecutor:
             project_state = {
                 "updated_at": updated_at,
                 "managed_links": self._merge_managed_links(
-                    existing=existing_project_state.get("managed_links"),
+                    existing=existing_project_state.managed_links,
                     touched_scopes=project_touched_scopes[project_name],
                     current_links=project_links.get(project_name, {}),
                 ),
                 "managed_paths": self._merge_managed_links(
-                    existing=existing_project_state.get("managed_paths"),
+                    existing=existing_project_state.managed_paths,
                     touched_scopes=project_touched_scopes[project_name],
                     current_links=project_paths.get(project_name, {}),
                 ),

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/models.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 from typing import Any
@@ -146,6 +146,68 @@ class SyncPlan:
         )
 
 
+@dataclass(frozen=True)
+class SyncState:
+    """Typed view of a repository's `.sync-state.json`.
+
+    All defensive normalization (missing keys, wrong JSON types, stray non-string
+    entries) happens once in `from_payload`; consumers read the typed fields
+    directly instead of re-guarding with `isinstance` at every call site.
+
+    `managed_links`/`managed_paths`/`managed_mcp` are `scope -> names` maps (the
+    live ownership model). The three `managed_*_links` lists are vestigial — no
+    production reader consumes them — but are kept for on-disk round-trips.
+    """
+
+    managed_links: dict[str, list[str]] = field(default_factory=dict)
+    managed_paths: dict[str, list[str]] = field(default_factory=dict)
+    managed_mcp: dict[str, list[str]] = field(default_factory=dict)
+    managed_skill_links: list[str] = field(default_factory=list)
+    managed_agent_links: list[str] = field(default_factory=list)
+    managed_workspace_links: list[str] = field(default_factory=list)
+    updated_at: str | None = None
+    skipped: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_payload(cls, payload: Any) -> "SyncState":
+        if not isinstance(payload, dict):
+            return cls()
+        updated_at = payload.get("updated_at")
+        return cls(
+            managed_links=cls._coerce_group(payload.get("managed_links")),
+            managed_paths=cls._coerce_group(payload.get("managed_paths")),
+            managed_mcp=cls._coerce_group(payload.get("managed_mcp")),
+            managed_skill_links=cls._coerce_str_list(
+                payload.get("managed_skill_links")
+            ),
+            managed_agent_links=cls._coerce_str_list(
+                payload.get("managed_agent_links")
+            ),
+            managed_workspace_links=cls._coerce_str_list(
+                payload.get("managed_workspace_links")
+            ),
+            updated_at=updated_at if isinstance(updated_at, str) else None,
+            skipped=cls._coerce_str_list(payload.get("skipped")),
+        )
+
+    @staticmethod
+    def _coerce_group(value: Any) -> dict[str, list[str]]:
+        if not isinstance(value, dict):
+            return {}
+        result: dict[str, list[str]] = {}
+        for scope, names in value.items():
+            if not isinstance(scope, str) or not isinstance(names, list):
+                continue
+            result[scope] = [name for name in names if isinstance(name, str)]
+        return result
+
+    @staticmethod
+    def _coerce_str_list(value: Any) -> list[str]:
+        if not isinstance(value, list):
+            return []
+        return [item for item in value if isinstance(item, str)]
+
+
 @dataclass(frozen=True)
 class WorkspaceConfig:
     name: str

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/planner.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from code_agnostic.apps.app_id import AppId, app_metadata
+from code_agnostic.apps.app_id import AppId, app_metadata, app_scope
 from code_agnostic.apps.common.compiled_planning import (
     plan_owned_compiled_text_action,
 )
@@ -283,15 +283,23 @@ class SyncPlanner:
             if existing_action is not None and isinstance(existing_action.payload, dict)
             else None
         )
+        state = self.core.load_state()
+        previously_managed_projects = set(
+            state.managed_mcp.get(app_scope(AppId.CLAUDE, "projects"), [])
+        )
         project_action = claude_service.build_project_mcp_action(
             self._claude_project_mcp,
             base_payload=base_payload,
+            previously_managed_projects=previously_managed_projects,
         )
         if existing_action is not None:
             # Carry global MCP ownership tracking onto the merged Claude action so
-            # top-level `mcpServers` orphans still get pruned on later applies.
-            project_action.scope = existing_action.scope
-            project_action.managed_entries = existing_action.managed_entries
+            # top-level `mcpServers` orphans still get pruned on later applies. The
+            # project-path ownership set by build_project_mcp_action is preserved.
+            project_action.scope = existing_action.scope or project_action.scope
+            merged_entries = dict(existing_action.managed_entries or {})
+            merged_entries.update(project_action.managed_entries or {})
+            project_action.managed_entries = merged_entries
         actions = [
             action
             for action in plan.actions
@@ -352,12 +360,8 @@ class SyncPlanner:
         skill_sources = project_source.list_skill_sources()
 
         state = project_source.load_state()
-        managed_links = state.get("managed_links", {})
-        if not isinstance(managed_links, dict):
-            managed_links = {}
-        managed_paths = state.get("managed_paths", {})
-        if not isinstance(managed_paths, dict):
-            managed_paths = {}
+        managed_links = state.managed_links
+        managed_paths = state.managed_paths
 
         actions: list[Action] = []
         skipped: list[str] = []
@@ -471,12 +475,8 @@ class SyncPlanner:
 
         repos = self.workspace_service.discover_git_repos(workspace_path)
         state = ws_source.load_state()
-        managed_links = state.get("managed_links", {})
-        if not isinstance(managed_links, dict):
-            managed_links = {}
-        managed_paths = state.get("managed_paths", {})
-        if not isinstance(managed_paths, dict):
-            managed_paths = {}
+        managed_links = state.managed_links
+        managed_paths = state.managed_paths
 
         has_config = ws_source.has_any_config()
         if not has_config and not repos:

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic/status.py

@@ -157,8 +157,8 @@ class StatusService:
                 root=project_config_dir(source_repo, project_name)
             )
             state = project_source.load_state()
-            has_managed_paths = bool(state.get("managed_paths"))
-            has_managed_links = bool(state.get("managed_links"))
+            has_managed_paths = bool(state.managed_paths)
+            has_managed_links = bool(state.managed_links)
             has_project_actions = any(
                 f":{project_name}:" in (action.scope or "")
                 for action in project_actions

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/code_agnostic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.6.0
+Version: 0.8.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.6.0 → code_agnostic-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-agnostic"
-version = "0.6.0"
+version = "0.8.0"
 description = "Centralized hub for LLM coding config: MCP, skills, rules, and agents."
 readme = "README.md"
 requires-python = ">=3.10"

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/tests/test_cli_disable_cleanup.py

@@ -6,6 +6,7 @@ import json
 from pathlib import Path
 
 from code_agnostic.__main__ import cli
+from code_agnostic.core.repository import CoreRepository
 
 
 def _write_skill(core_root: Path, name: str) -> None:
@@ -67,3 +68,50 @@ def test_disable_cursor_removes_skill_and_prunes_owned_mcp(
     # Flag is off.
     apps_cfg = json.loads((core_root / "config" / "apps.json").read_text())
     assert apps_cfg["cursor"] is False
+
+
+def test_disable_claude_prunes_project_mcp_keeps_user_project(
+    minimal_shared_config: Path,
+    core_root: Path,
+    tmp_path: Path,
+    cli_runner,
+    enable_app,
+) -> None:
+    enable_app("claude")
+    workspace_root = tmp_path / "workspace"
+    (workspace_root / "repo-a" / ".git").mkdir(parents=True)
+
+    core = CoreRepository(core_root)
+    core.add_workspace("myws", workspace_root)
+    (core.workspace_config_dir("myws") / "mcp.base.json").write_text(
+        json.dumps({"mcpServers": {"ws-server": {"url": "https://example.com/mcp"}}}),
+        encoding="utf-8",
+    )
+
+    # User's own project entry — must survive disable untouched.
+    config_path = tmp_path / ".claude.json"
+    user_project = str((tmp_path / "user-repo").resolve())
+    config_path.write_text(
+        json.dumps(
+            {"projects": {user_project: {"mcpServers": {"personal": {"type": "http"}}}}}
+        ),
+        encoding="utf-8",
+    )
+
+    assert cli_runner.invoke(cli, ["apply", "-a", "claude"]).exit_code == 0
+
+    projects = json.loads(config_path.read_text())["projects"]
+    repo_key = str((workspace_root / "repo-a").resolve())
+    assert "mcpServers" in projects[repo_key]
+    state = json.loads((core_root / ".sync-state.json").read_text())
+    assert repo_key in state["managed_mcp"]["app:claude:projects"]
+
+    # Disable → our project mcpServers pruned, user's project kept.
+    assert cli_runner.invoke(cli, ["apps", "disable", "-a", "claude"]).exit_code == 0
+
+    projects = json.loads(config_path.read_text())["projects"]
+    assert "mcpServers" not in projects.get(repo_key, {})
+    assert projects[user_project] == {"mcpServers": {"personal": {"type": "http"}}}
+
+    state = json.loads((core_root / ".sync-state.json").read_text())
+    assert "app:claude:projects" not in state.get("managed_mcp", {})

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/tests/test_common_repository.py

@@ -5,6 +5,7 @@ import pytest
 
 from code_agnostic.errors import InvalidConfigSchemaError, InvalidJsonFormatError
 from code_agnostic.core.repository import CoreRepository
+from code_agnostic.models import SyncState
 
 
 @pytest.fixture
@@ -17,14 +18,7 @@ def test_load_state_defaults_when_missing(core_repo: CoreRepository) -> None:
 
     state = repo.load_state()
 
-    assert state == {
-        "managed_skill_links": [],
-        "managed_agent_links": [],
-        "managed_workspace_links": [],
-        "managed_links": {},
-        "managed_paths": {},
-        "managed_mcp": {},
-    }
+    assert state == SyncState()
 
 
 def test_add_and_remove_workspace_persists_config(
@@ -203,14 +197,7 @@ def test_load_state_with_corrupted_json(
 
     state = repo.load_state()
 
-    assert state == {
-        "managed_skill_links": [],
-        "managed_agent_links": [],
-        "managed_workspace_links": [],
-        "managed_links": {},
-        "managed_paths": {},
-        "managed_mcp": {},
-    }
+    assert state == SyncState()
 
 
 def test_load_state_coerces_managed_skill_links_string_to_list(
@@ -224,7 +211,7 @@ def test_load_state_coerces_managed_skill_links_string_to_list(
 
     state = repo.load_state()
 
-    assert state["managed_skill_links"] == []
+    assert state.managed_skill_links == []
 
 
 def test_list_skill_sources_when_dir_missing(core_repo: CoreRepository) -> None:

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/tests/test_planner_executor.py

@@ -150,7 +150,7 @@ def test_build_plan_and_apply_create_opencode_and_workspace_links(
 
     ws_repo = WorkspaceConfigRepository(root=ws_config_dir)
     ws_state = ws_repo.load_state()
-    assert len(ws_state["managed_paths"]["rules"]) == 1
+    assert len(ws_state.managed_paths["rules"]) == 1
 
 
 def test_plan_marks_config_create_when_missing(
@@ -283,9 +283,7 @@ def test_targeted_execute_preserves_workspace_state_for_other_apps(
     assert failures == []
     assert applied > 0
 
-    managed_paths = WorkspaceConfigRepository(root=ws_config).load_state()[
-        "managed_paths"
-    ]
+    managed_paths = WorkspaceConfigRepository(root=ws_config).load_state().managed_paths
     assert "ws:codex:workspace_root_mcp" in managed_paths
     assert "ws:codex:repo_mcp" in managed_paths
     assert "ws:opencode:workspace_root_mcp" in managed_paths

{code_agnostic-0.6.0 → code_agnostic-0.8.0}/tests/test_sync_plan_model.py

@@ -5,6 +5,7 @@ from code_agnostic.models import (
     ActionKind,
     ActionStatus,
     SyncPlan,
+    SyncState,
 )
 
 
@@ -205,3 +206,46 @@ def test_is_valid_with_errors() -> None:
     plan = SyncPlan(actions=[], errors=[ValueError("err")], skipped=[])
 
     assert plan.is_valid() is False
+
+
+def test_sync_state_from_non_dict_payload_is_empty() -> None:
+    assert SyncState.from_payload(None) == SyncState()
+    assert SyncState.from_payload("garbage") == SyncState()
+    assert SyncState.from_payload([1, 2, 3]) == SyncState()
+
+
+def test_sync_state_from_payload_normalizes_all_fields() -> None:
+    state = SyncState.from_payload(
+        {
+            "managed_links": {"app:cursor:skills": ["/a", 5, "/b"]},
+            "managed_paths": {"scope": ["/p"], 7: ["ignored"]},
+            "managed_mcp": {"app:claude:projects": ["/repo"]},
+            "managed_skill_links": ["x", 1, "y"],
+            "skipped": ["s1"],
+            "updated_at": "2026-07-21T00:00:00",
+        }
+    )
+
+    # non-str entries and non-str scope keys are dropped
+    assert state.managed_links == {"app:cursor:skills": ["/a", "/b"]}
+    assert state.managed_paths == {"scope": ["/p"]}
+    assert state.managed_mcp == {"app:claude:projects": ["/repo"]}
+    assert state.managed_skill_links == ["x", "y"]
+    assert state.skipped == ["s1"]
+    assert state.updated_at == "2026-07-21T00:00:00"
+
+
+def test_sync_state_from_payload_coerces_wrong_types() -> None:
+    state = SyncState.from_payload(
+        {
+            "managed_links": "not-a-dict",
+            "managed_paths": {"scope": "not-a-list"},
+            "managed_skill_links": "not-a-list",
+            "updated_at": 12345,
+        }
+    )
+
+    assert state.managed_links == {}
+    assert state.managed_paths == {}  # non-list value drops the scope
+    assert state.managed_skill_links == []
+    assert state.updated_at is None