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

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

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

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

{code_agnostic-0.6.0 → code_agnostic-0.7.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,
@@ -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}:"
@@ -224,6 +227,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.7.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.7.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,29 @@ class SyncPlanner:
             if existing_action is not None and isinstance(existing_action.payload, dict)
             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()
+        )
         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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.6.0
+Version: 0.7.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.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-agnostic"
-version = "0.6.0"
+version = "0.7.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.7.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.7.0}/tests/test_workspace_config_sync.py

@@ -1,5 +1,7 @@
 """Tests for workspace-level config sync (MCP, skills, agents, rules)."""
 
+import json
+import shutil
 from pathlib import Path
 
 try:
@@ -747,6 +749,81 @@ def test_workspace_claude_mcp_merges_project_entries_into_home_config(
     }
 
 
+def test_workspace_claude_removed_repo_prunes_project_mcp_keeps_others(
+    minimal_shared_config: Path,
+    core_root: Path,
+    tmp_path: Path,
+    write_json,
+) -> None:
+    """P1: a repo removed from a workspace has its `projects.<path>.mcpServers`
+    pruned from ~/.claude.json on the next apply, while the other repo, the
+    workspace root, and a user-added project entry are all preserved."""
+    workspace_root = tmp_path / "workspace"
+    workspace_root.mkdir()
+    repo_a = workspace_root / "repo-a"
+    repo_b = workspace_root / "repo-b"
+    (repo_a / ".git").mkdir(parents=True)
+    (repo_b / ".git").mkdir(parents=True)
+
+    core = CoreRepository(core_root)
+    core.add_workspace("myws", workspace_root)
+
+    ws_config = core.workspace_config_dir("myws")
+    write_json(
+        ws_config / "mcp.base.json",
+        {"mcpServers": {"ws-server": {"url": "https://example.com/mcp"}}},
+    )
+
+    # User has their own project entry in ~/.claude.json that we must never touch.
+    user_project = str((tmp_path / "user-repo").resolve())
+    config_path = tmp_path / ".claude.json"
+    write_json(
+        config_path,
+        {"projects": {user_project: {"mcpServers": {"personal": {"type": "http"}}}}},
+    )
+
+    def _apply() -> dict:
+        plan = SyncPlanner(
+            core=core,
+            app_services=[_claude_service(tmp_path / ".claude")],
+        ).build()
+        _applied, failed, failures = SyncExecutor(core=core).execute(plan)
+        assert failed == 0, failures
+        return json.loads(config_path.read_text(encoding="utf-8"))
+
+    payload = _apply()
+    projects = payload["projects"]
+    assert str(workspace_root.resolve()) in projects
+    assert "mcpServers" in projects[str(repo_a.resolve())]
+    assert "mcpServers" in projects[str(repo_b.resolve())]
+    assert user_project in projects
+
+    state = json.loads((core_root / ".sync-state.json").read_text(encoding="utf-8"))
+    assert set(state["managed_mcp"]["app:claude:projects"]) == {
+        str(workspace_root.resolve()),
+        str(repo_a.resolve()),
+        str(repo_b.resolve()),
+    }
+
+    # Remove repo-a from the workspace and re-apply.
+    shutil.rmtree(repo_a)
+    payload = _apply()
+    projects = payload["projects"]
+
+    assert "mcpServers" not in projects.get(
+        str(repo_a.resolve()), {}
+    ), "removed repo's mcpServers must be pruned"
+    assert "mcpServers" in projects[str(repo_b.resolve())]
+    assert "mcpServers" in projects[str(workspace_root.resolve())]
+    assert projects[user_project] == {"mcpServers": {"personal": {"type": "http"}}}
+
+    state = json.loads((core_root / ".sync-state.json").read_text(encoding="utf-8"))
+    assert set(state["managed_mcp"]["app:claude:projects"]) == {
+        str(workspace_root.resolve()),
+        str(repo_b.resolve()),
+    }
+
+
 def test_workspace_targeted_plan_does_not_cleanup_other_app_scopes(
     minimal_shared_config: Path,
     core_root: Path,