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

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

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

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

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

@@ -103,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))
@@ -123,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
@@ -144,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)
             ):
@@ -163,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(

{code_agnostic-0.7.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.7.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.7.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.7.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.7.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.7.0 → code_agnostic-0.8.0}/code_agnostic/planner.py

@@ -284,14 +284,8 @@ class SyncPlanner:
             else None
         )
         state = self.core.load_state()
-        managed_mcp = state.get("managed_mcp")
-        if not isinstance(managed_mcp, dict):
-            managed_mcp = {}
-        prev_projects_raw = managed_mcp.get(app_scope(AppId.CLAUDE, "projects"), [])
-        previously_managed_projects = (
-            {path for path in prev_projects_raw if isinstance(path, str)}
-            if isinstance(prev_projects_raw, list)
-            else set()
+        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,
@@ -366,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] = []
@@ -485,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.7.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.7.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.7.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.7.0 → code_agnostic-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-agnostic"
-version = "0.7.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.7.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.7.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.7.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

{code_agnostic-0.7.0 → code_agnostic-0.8.0}/tests/test_workspace_config_sync.py

@@ -32,7 +32,7 @@ from code_agnostic.constants import (
 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 ActionKind, ActionStatus
+from code_agnostic.models import ActionKind, ActionStatus, SyncState
 from code_agnostic.planner import SyncPlanner
 
 
@@ -153,11 +153,11 @@ def test_workspace_config_repository_state_roundtrip(tmp_path: Path) -> None:
     repo = WorkspaceConfigRepository(root=ws_root)
 
     state = repo.load_state()
-    assert isinstance(state, dict)
+    assert isinstance(state, SyncState)
 
     repo.save_state({"managed_links": {"rules": ["/path/to/link"]}})
     loaded = repo.load_state()
-    assert loaded["managed_links"]["rules"] == ["/path/to/link"]
+    assert loaded.managed_links["rules"] == ["/path/to/link"]
 
 
 # --- Workspace rules files ---
@@ -920,8 +920,8 @@ def test_workspace_targeted_plan_cleans_stale_cursor_workspace_outputs(
     assert not stale_mcp.exists()
     assert not stale_agent.exists()
     state = ws_repo.load_state()
-    assert "ws:cursor:repo_mcp" not in state["managed_paths"]
-    assert "ws:cursor:repo_agents_dir" not in state["managed_links"]
+    assert "ws:cursor:repo_mcp" not in state.managed_paths
+    assert "ws:cursor:repo_agents_dir" not in state.managed_links
 
 
 def test_workspace_plan_skips_legacy_link_cleanup_when_same_path_is_now_generated(
@@ -1419,13 +1419,13 @@ def test_executor_persists_workspace_state_separately(
     # Workspace state persisted to workspace state file.
     ws_repo = WorkspaceConfigRepository(root=ws_config)
     ws_state = ws_repo.load_state()
-    managed = ws_state["managed_paths"]
+    managed = ws_state.managed_paths
     assert "rules" in managed
     assert len(managed["rules"]) == 1
 
     # Global state should not contain workspace links
     global_state = core.load_state()
-    assert "rules" not in global_state.get("managed_links", {})
+    assert "rules" not in global_state.managed_links
 
 
 # --- Full roundtrip with apply ---
@@ -1548,7 +1548,7 @@ def test_workspace_stale_skills_cleanup_when_skills_removed_for_codex(
     # Verify state was persisted with workspace scopes
     ws_repo = WorkspaceConfigRepository(root=ws_config)
     state = ws_repo.load_state()
-    assert "ws:codex:repo_skills_dir" in state["managed_paths"]
+    assert "ws:codex:repo_skills_dir" in state.managed_paths
 
     # Remove all skills from workspace config
     import shutil
@@ -1597,7 +1597,7 @@ def test_workspace_stale_skills_cleanup_when_skills_removed_for_claude(
 
     ws_repo = WorkspaceConfigRepository(root=ws_config)
     state = ws_repo.load_state()
-    assert "ws:claude:repo_skills_dir" in state["managed_paths"]
+    assert "ws:claude:repo_skills_dir" in state.managed_paths
 
     import shutil