code-agnostic 0.3.2__tar.gz → 0.3.3__tar.gz

{code_agnostic-0.3.2 → code_agnostic-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-agnostic
-Version: 0.3.2
+Version: 0.3.3
 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.3/code_agnostic/__main__.py

@@ -0,0 +1,62 @@
+"""CLI entrypoint - thin wrapper that wires command modules."""
+
+import click
+
+from code_agnostic.cli import AliasedGroup
+from code_agnostic.cli.commands.agents import agents_group
+from code_agnostic.cli.commands.apps import apps
+from code_agnostic.cli.commands.apply import apply
+from code_agnostic.cli.commands.explain_lossiness import explain_lossiness
+from code_agnostic.cli.commands.import_ import import_group
+from code_agnostic.cli.commands.mcp import mcp
+from code_agnostic.cli.commands.plan import plan
+from code_agnostic.cli.commands.restore import restore
+from code_agnostic.cli.commands.rules import rules
+from code_agnostic.cli.commands.skills import skills
+from code_agnostic.cli.commands.status import status
+from code_agnostic.cli.commands.validate import validate
+from code_agnostic.cli.commands.workspaces import workspaces
+
+
+@click.group(
+    cls=AliasedGroup,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """App-based config sync."""
+    ctx.obj = {}
+
+
+# Register individual commands
+cli.add_command(plan)
+cli.add_command(apply)
+cli.add_command(restore)
+cli.add_command(status)
+cli.add_command(validate)
+cli.add_command(explain_lossiness)
+
+# Register command groups
+cli.add_command(apps)
+cli.add_command(workspaces)
+cli.add_command(rules)
+cli.add_command(skills)
+cli.add_command(agents_group)
+cli.add_command(mcp)
+cli.add_command(import_group)
+
+
+def main() -> int:
+    try:
+        cli(standalone_mode=False)
+    except click.exceptions.Exit as exc:
+        code = exc.exit_code
+        return code if isinstance(code, int) else 1
+    except click.ClickException as exc:
+        exc.show()
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{code_agnostic-0.3.2 → code_agnostic-0.3.3}/code_agnostic/apps/app_id.py

@@ -1,6 +1,15 @@
 from enum import Enum
 from dataclasses import dataclass
 
+from code_agnostic.constants import (
+    CODEX_CONFIG_FILENAME,
+    CODEX_PROJECT_DIRNAME,
+    CURSOR_CONFIG_FILENAME,
+    CURSOR_PROJECT_DIRNAME,
+    OPENCODE_CONFIG_FILENAME,
+    OPENCODE_PROJECT_DIRNAME,
+)
+
 
 class AppId(str, Enum):
     CORE = "core"
@@ -19,6 +28,7 @@ class AppMetadata:
     supports_import_agents: bool
     supports_workspace_propagation: bool
     project_dir_name: str | None = None
+    config_filename: str | None = None
 
 
 APP_CATALOG: dict[AppId, AppMetadata] = {
@@ -40,7 +50,8 @@ APP_CATALOG: dict[AppId, AppMetadata] = {
         importable=True,
         supports_import_agents=True,
         supports_workspace_propagation=True,
-        project_dir_name=".opencode",
+        project_dir_name=OPENCODE_PROJECT_DIRNAME,
+        config_filename=OPENCODE_CONFIG_FILENAME,
     ),
     AppId.CURSOR: AppMetadata(
         app_id=AppId.CURSOR,
@@ -49,8 +60,9 @@ APP_CATALOG: dict[AppId, AppMetadata] = {
         toggleable=True,
         importable=True,
         supports_import_agents=True,
-        supports_workspace_propagation=False,
-        project_dir_name=".cursor",
+        supports_workspace_propagation=True,
+        project_dir_name=CURSOR_PROJECT_DIRNAME,
+        config_filename=CURSOR_CONFIG_FILENAME,
     ),
     AppId.CODEX: AppMetadata(
         app_id=AppId.CODEX,
@@ -60,7 +72,8 @@ APP_CATALOG: dict[AppId, AppMetadata] = {
         importable=True,
         supports_import_agents=True,
         supports_workspace_propagation=True,
-        project_dir_name=".codex",
+        project_dir_name=CODEX_PROJECT_DIRNAME,
+        config_filename=CODEX_CONFIG_FILENAME,
     ),
 }
 
@@ -74,6 +87,11 @@ def app_label(app: AppId | str) -> str:
     return app_metadata(app).label
 
 
+def app_scope(app: AppId | str, resource: str) -> str:
+    app_id = app if isinstance(app, AppId) else AppId(app)
+    return f"app:{app_id.value}:{resource}"
+
+
 def app_ids_by_capability(
     *,
     targetable: bool | None = None,

{code_agnostic-0.3.2 → code_agnostic-0.3.3}/code_agnostic/apps/codex/config_repository.py

@@ -9,12 +9,18 @@ except ModuleNotFoundError:  # pragma: no cover
 import tomlkit
 
 from code_agnostic.apps.common.interfaces.repositories import IAppConfigRepository
+from code_agnostic.constants import (
+    AGENTS_DIRNAME,
+    CODEX_CONFIG_FILENAME,
+    CODEX_PROJECT_DIRNAME,
+    SKILLS_DIRNAME,
+)
 from code_agnostic.errors import InvalidConfigSchemaError, InvalidJsonFormatError
 
 
 class CodexConfigRepository(IAppConfigRepository):
     def __init__(self, root: Path | None = None) -> None:
-        self._root = root or (Path.home() / ".codex")
+        self._root = root or (Path.home() / CODEX_PROJECT_DIRNAME)
 
     @property
     def root(self) -> Path:
@@ -22,15 +28,15 @@ class CodexConfigRepository(IAppConfigRepository):
 
     @property
     def config_path(self) -> Path:
-        return self.root / "config.toml"
+        return self.root / CODEX_CONFIG_FILENAME
 
     @property
     def skills_dir(self) -> Path:
-        return self.root / "skills"
+        return self.root / SKILLS_DIRNAME
 
     @property
     def agents_dir(self) -> Path:
-        return self.root / "agents"
+        return self.root / AGENTS_DIRNAME
 
     def load_config(self) -> dict[str, Any]:
         if not self.config_path.exists() or self.config_path.stat().st_size == 0:

{code_agnostic-0.3.2 → code_agnostic-0.3.3}/code_agnostic/apps/codex/schema.json

@@ -18,6 +18,10 @@
     "AbsolutePathBuf": {
       "type": "string"
     },
+    "AppToolApproval": {
+      "enum": ["auto", "prompt", "approve"],
+      "type": "string"
+    },
     "AgentRoleToml": {
       "type": "object",
       "additionalProperties": false,
@@ -41,6 +45,17 @@
         "$ref": "#/definitions/AgentRoleToml"
       }
     },
+    "McpServerToolConfig": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "approval_mode": {
+          "allOf": [{ "$ref": "#/definitions/AppToolApproval" }],
+          "description": "Approval mode for this tool."
+        }
+      },
+      "description": "Per-tool approval settings for a single MCP server tool."
+    },
     "RawMcpServerConfig": {
       "type": "object",
       "additionalProperties": false,
@@ -57,12 +72,24 @@
         "env_http_headers": { "type": "object", "additionalProperties": { "type": "string" } },
         "env_vars": { "type": "array", "items": { "type": "string" } },
         "http_headers": { "type": "object", "additionalProperties": { "type": "string" } },
+        "name": {
+          "type": "string",
+          "default": null,
+          "description": "Legacy display-name field accepted for backward compatibility."
+        },
         "oauth_resource": { "type": "string", "default": null },
         "required": { "type": "boolean" },
         "scopes": { "type": "array", "items": { "type": "string" } },
         "startup_timeout_ms": { "type": "integer", "minimum": 0 },
         "startup_timeout_sec": { "type": "number" },
         "tool_timeout_sec": { "type": "number" },
+        "tools": {
+          "type": "object",
+          "default": null,
+          "additionalProperties": {
+            "$ref": "#/definitions/McpServerToolConfig"
+          }
+        },
         "url": { "type": "string" }
       }
     }

code_agnostic-0.3.3/code_agnostic/apps/codex/service.py

@@ -0,0 +1,268 @@
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+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.common.framework import (
+    RegisteredAppConfigService,
+    format_schema_error,
+)
+from code_agnostic.apps.codex.config_repository import CodexConfigRepository
+from code_agnostic.apps.codex.mapper import CodexMCPMapper
+from code_agnostic.apps.codex.schema_repository import CodexSchemaRepository
+from code_agnostic.apps.common.interfaces.mapper import IAppMCPMapper
+from code_agnostic.apps.common.interfaces.repositories import (
+    IAppConfigRepository,
+    ISchemaRepository,
+)
+from code_agnostic.apps.common.models import MCPServerDTO
+from code_agnostic.errors import (
+    InvalidConfigSchemaError,
+    InvalidJsonFormatError,
+)
+from code_agnostic.models import Action, ActionKind, ActionStatus
+from code_agnostic.utils import read_json_safe
+from code_agnostic.skills.compilers import CodexSkillCompiler
+from code_agnostic.skills.parser import parse_skill
+
+
+class CodexConfigService(RegisteredAppConfigService):
+    APP_ID = AppId.CODEX
+    APP_LABEL = app_label(APP_ID)
+
+    def __init__(
+        self,
+        repository: CodexConfigRepository,
+        mapper: IAppMCPMapper,
+        schema_repository: ISchemaRepository,
+        base_config_path: Path | None = None,
+    ) -> None:
+        self._repository = repository
+        self._codex_repo = repository
+        self._mapper = mapper
+        self._schema_repository = schema_repository
+        self._base_config_path = base_config_path
+        self._validator = Draft7Validator(self._schema_repository.load_schema())
+
+    @classmethod
+    def create_default(cls, root: Path | None = None) -> "CodexConfigService":
+        if root is not None:
+            return cls(
+                repository=CodexConfigRepository(root=root),
+                mapper=CodexMCPMapper(),
+                schema_repository=CodexSchemaRepository(),
+                base_config_path=None,
+            )
+        from code_agnostic.core.repository import CoreRepository
+
+        core = CoreRepository()
+        return cls(
+            repository=CodexConfigRepository(root=root),
+            mapper=CodexMCPMapper(),
+            schema_repository=CodexSchemaRepository(),
+            base_config_path=core.codex_base_path,
+        )
+
+    @property
+    def app_id(self) -> AppId:
+        return self.APP_ID
+
+    @property
+    def action_kind(self) -> ActionKind:
+        return ActionKind.WRITE_TEXT
+
+    @property
+    def repository(self) -> IAppConfigRepository:
+        return self._repository
+
+    @property
+    def mapper(self) -> IAppMCPMapper:
+        return self._mapper
+
+    def validate_config(self, payload: Any) -> None:
+        error = next(iter(self._validator.iter_errors(payload)), None)
+        if error is not None:
+            raise InvalidConfigSchemaError(
+                self.repository.config_path, format_schema_error(error)
+            )
+
+    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:
+        merged["mcp_servers"] = desired_mcp
+
+    def derive_status(
+        self, existing: dict[str, Any], merged: dict[str, Any]
+    ) -> ActionStatus:
+        rendered = self.repository.serialize_config(merged)
+        existing_text = (
+            self.repository.config_path.read_text(encoding="utf-8")
+            if self.repository.config_path.exists()
+            else ""
+        )
+        if not self.repository.config_path.exists():
+            return ActionStatus.CREATE
+        if existing_text == rendered:
+            return ActionStatus.NOOP
+        return ActionStatus.UPDATE
+
+    def build_action(
+        self,
+        common_servers: dict[str, MCPServerDTO],
+        agent_sources: list[Path] | None = None,
+    ) -> Action:
+        existing = self._codex_repo.load_config()
+        if existing or self._codex_repo.config_path.exists():
+            self.validate_config(existing)
+
+        desired_mcp = self.mapper.from_common(common_servers)
+        merged = dict(existing)
+        base = self._load_base_config()
+        for key, value in base.items():
+            if key == "mcp_servers":
+                continue
+            if key == "agents" and isinstance(value, dict):
+                merged["agents"] = self._merge_agents_payload(
+                    merged.get("agents"), value
+                )
+                continue
+            merged[key] = deepcopy(value)
+        self.set_mcp_payload(merged, desired_mcp)
+        if agent_sources:
+            merged["agents"] = self._merge_agents_payload(
+                merged.get("agents"),
+                self._build_agent_registry(agent_sources),
+            )
+        self.validate_config(merged)
+
+        return Action(
+            kind=self.action_kind,
+            path=self.repository.config_path,
+            status=self.derive_status(existing, merged),
+            detail=f"sync {self.app_id.value} config from common mcp base",
+            payload=self.build_action_payload(merged),
+            app=self.app_id.value,
+        )
+
+    def _merge_agents_payload(
+        self, existing: Any, overlay: dict[str, Any]
+    ) -> dict[str, Any]:
+        merged = dict(existing) if isinstance(existing, dict) else {}
+        for key, value in overlay.items():
+            merged[key] = deepcopy(value)
+        return merged
+
+    def _build_agent_registry(self, sources: list[Path]) -> dict[str, dict[str, Any]]:
+        registry: dict[str, dict[str, Any]] = {}
+        for source in sources:
+            try:
+                agent = parse_agent(source)
+            except InvalidConfigSchemaError:
+                raise
+            except Exception as exc:
+                raise InvalidConfigSchemaError(source, str(exc)) from exc
+
+            agent_name = agent.metadata.name or agent.name
+            target_name = (
+                normalize_codex_agent_filename(agent.metadata.name, agent.name)
+                + ".toml"
+            )
+            entry: dict[str, Any] = {
+                "description": agent.metadata.description or agent_name,
+                "config_file": (Path("agents") / target_name).as_posix(),
+            }
+            if agent.metadata.nickname_candidates:
+                entry["nickname_candidates"] = list(agent.metadata.nickname_candidates)
+            registry[agent_name] = entry
+        return registry
+
+    def plan_skill_actions(
+        self,
+        sources: list[Path],
+        target_dir: Path,
+        scope: str,
+        app: str,
+        managed_paths: list[Path],
+        removable_links: list[Path],
+    ) -> tuple[list[Action], list[Path], list[str]]:
+        compiler = CodexSkillCompiler()
+        return self._plan_compiled_text_actions(
+            sources=sources,
+            scope=scope,
+            app=app,
+            managed_paths=managed_paths,
+            removable_links=removable_links,
+            compile_source=lambda source: (
+                target_dir / source.name / "SKILL.md",
+                compiler.compile(
+                    parse_skill(
+                        source / "SKILL.md"
+                        if (source / "SKILL.md").exists()
+                        else source
+                    )
+                ),
+            ),
+            create_detail="create compiled codex skill",
+            noop_detail="compiled codex skill already up to date",
+            update_detail="update compiled codex skill",
+            conflict_message="Codex skill sync skipped (conflict): {target}",
+        )
+
+    def plan_agent_actions(
+        self,
+        sources: list[Path],
+        target_dir: Path,
+        scope: str,
+        app: str,
+        managed_paths: list[Path],
+        removable_links: list[Path],
+    ) -> tuple[list[Action], list[Path], list[str]]:
+        compiler = CodexAgentCompiler()
+
+        def compile_source(source: Path) -> tuple[Path, str]:
+            try:
+                agent = parse_agent(source)
+                payload = compiler.compile(agent)
+            except InvalidConfigSchemaError:
+                raise
+            except Exception as exc:
+                raise InvalidConfigSchemaError(source, str(exc)) from exc
+
+            target_name = (
+                normalize_codex_agent_filename(agent.metadata.name, agent.name)
+                + ".toml"
+            )
+            return target_dir / target_name, payload
+
+        return self._plan_compiled_text_actions(
+            sources=sources,
+            scope=scope,
+            app=app,
+            managed_paths=managed_paths,
+            removable_links=removable_links,
+            compile_source=compile_source,
+            create_detail="create compiled codex agent",
+            noop_detail="compiled codex agent already up to date",
+            update_detail="update compiled codex agent",
+            conflict_message="Codex agent sync skipped (conflict): {target}",
+        )
+
+    def _load_base_config(self) -> dict[str, Any]:
+        if self._base_config_path is None or not self._base_config_path.exists():
+            return {}
+        payload, error = read_json_safe(self._base_config_path)
+        if error is not None:
+            raise InvalidJsonFormatError(self._base_config_path, error)
+        if not isinstance(payload, dict):
+            raise InvalidConfigSchemaError(
+                self._base_config_path, "must be a JSON object"
+            )
+        return payload