code-agnostic 0.3.17__tar.gz → 0.4.0__tar.gz

{code_agnostic-0.3.17 → code_agnostic-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.3.17
+Version: 0.4.0
 Summary: Centralized hub for LLM coding config: MCP, skills, rules, and agents.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -305,7 +305,10 @@ code-agnostic workspaces list
 
 Prevent synced paths from showing up in `git status`. Managed per-workspace with customizable patterns.
 
+Writing `.git/info/exclude` is always explicit — `apply` does **not** touch it by default. Opt in per run with `apply --apply-excludes`, or use the standalone command:
+
 ```bash
+code-agnostic apply --apply-excludes                           # apply + write excludes
 code-agnostic workspaces git-exclude                            # all workspaces
 code-agnostic workspaces git-exclude -w myproject               # one workspace
 code-agnostic workspaces exclude-add --pattern "*.generated" -w myproject

{code_agnostic-0.3.17 → code_agnostic-0.4.0}/README.md

@@ -280,7 +280,10 @@ code-agnostic workspaces list
 
 Prevent synced paths from showing up in `git status`. Managed per-workspace with customizable patterns.
 
+Writing `.git/info/exclude` is always explicit — `apply` does **not** touch it by default. Opt in per run with `apply --apply-excludes`, or use the standalone command:
+
 ```bash
+code-agnostic apply --apply-excludes                           # apply + write excludes
 code-agnostic workspaces git-exclude                            # all workspaces
 code-agnostic workspaces git-exclude -w myproject               # one workspace
 code-agnostic workspaces exclude-add --pattern "*.generated" -w myproject

{code_agnostic-0.3.17 → code_agnostic-0.4.0}/code_agnostic/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.17"
+__version__ = "0.4.0"

code_agnostic-0.4.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.interfaces.repositories import ISourceRepository
+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.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: ISourceRepository) -> 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.17 → code_agnostic-0.4.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: