capacium 0.15.0__py3-none-any.whl

capacium/__init__.py

@@ -0,0 +1,13 @@
+"""
+Capacium — Capability Packaging System
+Agent-agnostic, manifest-first packaging for AI agent capabilities.
+"""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("capacium")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__author__ = "Capacium"

capacium/adaptation/__init__.py

@@ -0,0 +1,4 @@
+from .adapter import CapabilityAdapter
+from .registry import AdaptationRegistry
+
+__all__ = ["CapabilityAdapter", "AdaptationRegistry"]

capacium/adaptation/adapter.py

@@ -0,0 +1,121 @@
+"""Capability Adapter — transforms capabilities between framework formats.
+
+Uses exporters for format conversion and the adaptation registry
+for target-specific configuration.
+"""
+from typing import Any, Dict, List, Optional
+
+from ..manifest import Manifest
+from ..exporters import MCPExporter, A2AExporter
+from .registry import AdaptationRegistry, AdaptationTarget
+
+
+class AdaptationError(Exception):
+    """Raised when adaptation fails."""
+    pass
+
+
+class CapabilityAdapter:
+    """Adapts capabilities to target framework formats."""
+
+    def __init__(self):
+        self._registry = AdaptationRegistry()
+        self._exporters = {
+            "mcp-server": MCPExporter(),
+            "a2a-agent": A2AExporter(),
+        }
+
+    @property
+    def registry(self) -> AdaptationRegistry:
+        return self._registry
+
+    def adapt(
+        self,
+        manifest: Manifest,
+        target: str,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Adapt a manifest to target framework format.
+
+        Args:
+            manifest: Source capability manifest
+            target: Target framework name (e.g. "mcp-server", "a2a-agent")
+            options: Optional adaptation options (transport, etc.)
+
+        Returns:
+            Adapted output as dict
+
+        Raises:
+            AdaptationError: If adaptation not possible
+        """
+        target_info = self._registry.get(target)
+        if target_info is None:
+            available = ", ".join(self._registry.list_targets())
+            raise AdaptationError(
+                f"Unknown adaptation target '{target}'. Available: {available}"
+            )
+
+        # Check if we have an exporter for this target
+        exporter = self._exporters.get(target)
+        if exporter is not None:
+            if not exporter.can_export(manifest):
+                raise AdaptationError(
+                    f"Cannot adapt manifest kind '{manifest.kind}' to '{target}'"
+                )
+            result = exporter.export(manifest)
+        else:
+            # Generic adaptation via target info
+            result = self._generic_adapt(manifest, target_info)
+
+        # Apply target-specific options
+        if options:
+            result = self._apply_options(result, target_info, options)
+
+        return result
+
+    def can_adapt(self, manifest: Manifest, target: str) -> bool:
+        """Check if a manifest can be adapted to the target."""
+        target_info = self._registry.get(target)
+        if target_info is None:
+            return False
+        exporter = self._exporters.get(target)
+        if exporter is not None:
+            return exporter.can_export(manifest)
+        return True  # Generic adaptation always possible
+
+    def list_targets(self, manifest: Optional[Manifest] = None) -> List[str]:
+        """List available adaptation targets, optionally filtered by manifest compatibility."""
+        if manifest is None:
+            return self._registry.list_targets()
+        return [t for t in self._registry.list_targets() if self.can_adapt(manifest, t)]
+
+    def _generic_adapt(self, manifest: Manifest, target: AdaptationTarget) -> Dict[str, Any]:
+        """Generic adaptation when no specific exporter exists."""
+        result: Dict[str, Any] = {
+            "name": manifest.name,
+            "version": manifest.version,
+            "description": manifest.description,
+            "kind": manifest.kind,
+            "adapted_from": "capacium",
+            "target": target.name,
+        }
+        if target.supports_tools and manifest.capabilities:
+            result["tools"] = [
+                {"name": c.get("name", ""), "description": c.get("description", "")}
+                for c in manifest.capabilities
+            ]
+        if manifest.runtimes:
+            result["runtime"] = manifest.runtimes
+        return result
+
+    def _apply_options(
+        self, result: Dict[str, Any], target: AdaptationTarget, options: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Apply adaptation options to result."""
+        if target.requires_transport and "transport" in options:
+            result["transport"] = options["transport"]
+        if "command" in options:
+            result["command"] = options["command"]
+        if "args" in options:
+            result["args"] = options["args"]
+        return result

capacium/adaptation/registry.py

@@ -0,0 +1,58 @@
+"""Registry of supported adaptation targets.
+
+Each target describes a framework + what kind of output it needs.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass
+class AdaptationTarget:
+    """Describes a target framework for adaptation."""
+    name: str  # e.g. "mcp-server", "a2a-agent", "claude-desktop"
+    description: str = ""
+    output_format: str = "json"  # json, yaml, toml
+    requires_transport: bool = False  # needs transport config (e.g. MCP)
+    supports_tools: bool = True
+    supports_resources: bool = True
+    supports_prompts: bool = False
+
+
+class AdaptationRegistry:
+    """Registry of known adaptation targets."""
+
+    def __init__(self):
+        self._targets: Dict[str, AdaptationTarget] = {}
+        self._register_defaults()
+
+    def _register_defaults(self):
+        """Register built-in adaptation targets."""
+        self.register(AdaptationTarget(
+            name="mcp-server",
+            description="Model Context Protocol server descriptor",
+            requires_transport=True,
+            supports_prompts=True,
+        ))
+        self.register(AdaptationTarget(
+            name="a2a-agent",
+            description="Google A2A agent card",
+            supports_prompts=False,
+        ))
+        self.register(AdaptationTarget(
+            name="claude-desktop",
+            description="Claude Desktop MCP config entry",
+            output_format="json",
+            requires_transport=True,
+        ))
+
+    def register(self, target: AdaptationTarget) -> None:
+        self._targets[target.name] = target
+
+    def get(self, name: str) -> Optional[AdaptationTarget]:
+        return self._targets.get(name)
+
+    def list_targets(self) -> List[str]:
+        return list(self._targets.keys())
+
+    def all(self) -> List[AdaptationTarget]:
+        return list(self._targets.values())

capacium/adapters/__init__.py

@@ -0,0 +1,124 @@
+from typing import List
+from .base import FrameworkAdapter
+from .opencode import OpenCodeAdapter, OpencodeCommandAdapter
+from .claude_code import ClaudeCodeAdapter
+from .gemini_cli import GeminiCLIAdapter
+from .cursor import CursorAdapter
+from .continue_dev import ContinueDevAdapter
+from .claude_desktop import ClaudeDesktopAdapter
+from .windsurf import WindsurfAdapter
+from .cline import ClineAdapter
+from .zed import ZedAdapter
+from .codex import CodexAdapter
+from .antigravity import AntigravityAdapter
+from .sourcegraph_cody import SourcegraphCodyAdapter
+from .librechat import LibreChatAdapter
+from .chainlit import ChainlitAdapter
+from .cherry_studio import CherryStudioAdapter
+from .nextchat import NextChatAdapter
+from .desktop_commander import DesktopCommanderAdapter
+from .junie import JunieAdapter
+from .stub_adapters import LutraAdapter, SergeAdapter, NotebookLMAdapter, McpRemoteAdapter
+from .roo_code import RooCodeAdapter
+from .goose import GooseAdapter
+from .aider import AiderAdapter
+from .openclaw import OpenClawAdapter
+from .hermes import HermesAdapter
+from .qwen import QwenAdapter
+from .copilot import CopilotAdapter
+from .langchain_bridge import LangChainToolAdapter, FlowiseAdapter
+
+_ADAPTER_REGISTRY: dict[str, type[FrameworkAdapter]] = {}
+
+
+def register_adapter(name: str, adapter_cls: type[FrameworkAdapter]) -> None:
+    _ADAPTER_REGISTRY[name] = adapter_cls
+
+
+def get_adapter(name: str) -> FrameworkAdapter:
+    cls = _ADAPTER_REGISTRY.get(name)
+    if cls is None:
+        raise ValueError(f"Unknown framework adapter: {name}")
+    return cls()
+
+
+def get_adapter_for_manifest(manifest) -> FrameworkAdapter:
+    frameworks = (
+        manifest.get_target_frameworks()
+        if hasattr(manifest, "get_target_frameworks")
+        else getattr(manifest, "frameworks", None) or []
+    )
+    if not frameworks:
+        return get_adapter("opencode")
+    for fw in frameworks:
+        if fw in _ADAPTER_REGISTRY:
+            return get_adapter(fw)
+    return get_adapter("opencode")
+
+
+def get_adapters_for_manifest(manifest) -> List[FrameworkAdapter]:
+    frameworks = (
+        manifest.get_target_frameworks()
+        if hasattr(manifest, "get_target_frameworks")
+        else getattr(manifest, "frameworks", None) or []
+    )
+    if not frameworks:
+        return [get_adapter("opencode")]
+    adapters = []
+    for fw in frameworks:
+        fw_clean = fw.strip()
+        if fw_clean in _ADAPTER_REGISTRY:
+            adapters.append(get_adapter(fw_clean))
+    if not adapters:
+        adapters.append(get_adapter("opencode"))
+    return adapters
+
+
+def list_registered_adapters() -> List[str]:
+    """Return sorted list of all registered adapter names."""
+    return sorted(_ADAPTER_REGISTRY.keys())
+
+
+# ── Tier 1: Development & Engineering ──────────────────────────────────
+register_adapter("opencode", OpenCodeAdapter)
+register_adapter("opencode-command", OpencodeCommandAdapter)
+register_adapter("claude-desktop", ClaudeDesktopAdapter)
+register_adapter("claude-code", ClaudeCodeAdapter)
+register_adapter("cursor", CursorAdapter)
+register_adapter("windsurf", WindsurfAdapter)
+register_adapter("cline", ClineAdapter)
+register_adapter("zed", ZedAdapter)
+register_adapter("sourcegraph-cody", SourcegraphCodyAdapter)
+register_adapter("antigravity", AntigravityAdapter)
+register_adapter("continue-dev", ContinueDevAdapter)
+register_adapter("codex", CodexAdapter)
+register_adapter("qwen", QwenAdapter)
+register_adapter("gemini-cli", GeminiCLIAdapter)
+
+# ── Tier 2: Specialized / Workflow ─────────────────────────────────────
+register_adapter("librechat", LibreChatAdapter)
+register_adapter("chainlit", ChainlitAdapter)
+register_adapter("cherry-studio", CherryStudioAdapter)
+register_adapter("nextchat", NextChatAdapter)
+register_adapter("desktop-commander", DesktopCommanderAdapter)
+register_adapter("notebooklm", NotebookLMAdapter)
+register_adapter("lutra", LutraAdapter)
+register_adapter("serge", SergeAdapter)
+register_adapter("mcp-remote", McpRemoteAdapter)
+
+# ── Tier 3: Extended Skill Clients ─────────────────────────────────────
+register_adapter("roo-code", RooCodeAdapter)
+register_adapter("goose", GooseAdapter)
+register_adapter("aider", AiderAdapter)
+register_adapter("openclaw", OpenClawAdapter)
+
+# ── Tier 3c: Junie ──────────────────────────────────────────────────────
+register_adapter("junie", JunieAdapter)
+
+# ── Tier 4: Agent Flow Bridging ────────────────────────────────────────
+register_adapter("langchain", LangChainToolAdapter)
+register_adapter("flowise", FlowiseAdapter)
+
+# ── Tier 5: SKILL.md-Capable Agents (2026 standard) ────────────────────
+register_adapter("hermes", HermesAdapter)
+register_adapter("copilot", CopilotAdapter)

capacium/adapters/aider.py

@@ -0,0 +1,91 @@
+"""Aider AI coding assistant MCP adapter.
+
+Config: ~/.aider.conf.yml or project-level .aider.conf.yml
+Aider can connect to MCP servers via its configuration YAML.
+"""
+from pathlib import Path
+
+from ..storage import StorageManager
+from .base import FrameworkAdapter, ensure_package_dir
+from .mcp_config_patcher import McpConfigPatcher
+
+
+class AiderAdapter(FrameworkAdapter):
+
+    def __init__(self):
+        self.storage = StorageManager()
+        self.config_path = Path.home() / ".aider.conf.yml"
+
+    def install_skill(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        print("Aider does not support skill symlinking. Use 'mcp-server' kind.")
+        return False
+
+    def remove_skill(self, cap_name: str, owner: str = "global") -> bool:
+        return False
+
+    def install_mcp_server(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        package_dir = ensure_package_dir(self.storage, cap_name, version, source_dir, owner=owner)
+
+        from ..manifest import Manifest
+        manifest = Manifest.detect_from_directory(package_dir)
+        mcp_meta = manifest.get_mcp_metadata()
+        entry = McpConfigPatcher.build_mcp_entry(cap_name, package_dir, mcp_meta)
+
+        McpConfigPatcher.backup(self.config_path)
+
+        config: dict = {}
+        if self.config_path.exists():
+            try:
+                import yaml
+                with open(self.config_path) as f:
+                    config = yaml.safe_load(f) or {}
+            except ImportError:
+                config = {}
+
+        servers = config.setdefault("mcp-servers", {})
+        servers[cap_name] = entry
+
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            import yaml
+            with open(self.config_path, "w") as f:
+                yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+        except ImportError:
+            # Minimal YAML fallback
+            with open(self.config_path, "w") as f:
+                f.write("mcp-servers:\n")
+                for sname, sentry in servers.items():
+                    f.write(f"  {sname}:\n")
+                    for k, v in sentry.items():
+                        f.write(f"    {k}: {v}\n")
+
+        return True
+
+    def remove_mcp_server(self, cap_name: str, owner: str = "global") -> bool:
+        if not self.config_path.exists():
+            return True
+
+        McpConfigPatcher.backup(self.config_path)
+        try:
+            import yaml
+            with open(self.config_path) as f:
+                config = yaml.safe_load(f) or {}
+            servers = config.get("mcp-servers", {})
+            if cap_name in servers:
+                del servers[cap_name]
+                with open(self.config_path, "w") as f:
+                    yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+        except ImportError:
+            pass
+        return True
+
+    def capability_exists(self, cap_name: str) -> bool:
+        if not self.config_path.exists():
+            return False
+        try:
+            import yaml
+            with open(self.config_path) as f:
+                config = yaml.safe_load(f) or {}
+            return cap_name in config.get("mcp-servers", {})
+        except ImportError:
+            return False

capacium/adapters/antigravity.py

@@ -0,0 +1,78 @@
+"""Google Antigravity adapter.
+
+Skills: ~/.gemini/config/skills/<name>/SKILL.md
+MCP:    ~/.gemini/config/mcp_config.json
+"""
+import json
+import shutil
+from pathlib import Path
+
+from ..storage import StorageManager
+from ..symlink_manager import SymlinkManager
+from .base import FrameworkAdapter, _cap_id, ensure_package_dir
+from .mcp_config_patcher import McpConfigPatcher
+
+
+class AntigravityAdapter(FrameworkAdapter):
+
+    def __init__(self):
+        self.storage = StorageManager()
+        self.symlink_manager = SymlinkManager()
+        self.config_path = Path.home() / ".gemini" / "config" / "mcp_config.json"
+        self.skills_dir = Path.home() / ".gemini" / "config" / "skills"
+        self.legacy_skills_dir = Path.home() / ".gemini" / "antigravity" / "skills"
+        self.skills_dir.mkdir(parents=True, exist_ok=True)
+
+    def install_skill(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        package_dir = ensure_package_dir(self.storage, cap_name, version, source_dir, owner=owner)
+
+        link_path = self.skills_dir / _cap_id(cap_name, owner)
+        success = self.symlink_manager.create_symlink(package_dir, link_path)
+
+        metadata_path = package_dir / ".capacium-meta.json"
+        with open(metadata_path, "w") as f:
+            json.dump({"name": cap_name, "version": version, "owner": owner}, f, indent=2)
+
+        return success
+
+    def remove_skill(self, cap_name: str, owner: str = "global") -> bool:
+        for skills_dir in (self.skills_dir, self.legacy_skills_dir):
+            link_path = skills_dir / _cap_id(cap_name, owner)
+            if link_path.exists() or link_path.is_symlink():
+                if link_path.is_symlink():
+                    self.symlink_manager.remove_symlink(link_path)
+                elif link_path.is_dir():
+                    shutil.rmtree(link_path)
+                else:
+                    link_path.unlink()
+        return True
+
+    def install_mcp_server(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        package_dir = ensure_package_dir(self.storage, cap_name, version, source_dir, owner=owner)
+
+        from ..manifest import Manifest
+        manifest = Manifest.detect_from_directory(package_dir)
+        mcp_meta = manifest.get_mcp_metadata()
+
+        return McpConfigPatcher.inject_json_mcp_server(
+            config_path=self.config_path,
+            server_key=McpConfigPatcher.build_server_key(cap_name, owner),
+            mcp_section_key="mcpServers",
+            cap_name=cap_name,
+            source_dir=package_dir,
+            mcp_meta=mcp_meta,
+        )
+
+    def remove_mcp_server(self, cap_name: str, owner: str = "global") -> bool:
+        return McpConfigPatcher.remove_json_mcp_server(
+            self.config_path, McpConfigPatcher.build_server_key(cap_name, owner), "mcpServers",
+        )
+
+    def capability_exists(self, cap_name: str, owner: str = "global") -> bool:
+        for skills_dir in (self.skills_dir, self.legacy_skills_dir):
+            link_path = skills_dir / _cap_id(cap_name, owner)
+            if link_path.exists() and link_path.is_symlink():
+                return True
+        return McpConfigPatcher.mcp_server_exists_json(
+            self.config_path, McpConfigPatcher.build_server_key(cap_name, owner), "mcpServers",
+        )

capacium/adapters/base.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+def _cap_id(cap_name: str, owner: str = "global") -> str:
+    """Return the client-facing filesystem name for a capability.
+
+    Skill clients discover direct children of their skills directory, so owner
+    namespaces cannot be represented as nested directories here. Cross-owner
+    conflicts are handled before adapter installation.
+    """
+    return cap_name
+
+
+def ensure_package_dir(storage, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> Path:
+    """Copy source_dir → package_dir if they differ. Returns package_dir."""
+    package_dir = storage.get_package_dir(cap_name, version, owner=owner)
+    if source_dir.resolve() != package_dir.resolve():
+        import shutil
+        if package_dir.exists():
+            shutil.rmtree(package_dir)
+        shutil.copytree(source_dir, package_dir)
+    return package_dir
+
+
+class FrameworkAdapter(ABC):
+    def install_capability(self, cap_name: str, version: str, source_dir: Path, owner: str = "global", kind: str = "skill") -> bool:
+        if kind == "mcp-server":
+            return self.install_mcp_server(cap_name, version, source_dir, owner)
+        from ..models import SKILL_LAYER_KIND_VALUES
+        if kind not in SKILL_LAYER_KIND_VALUES:
+            # Kind-placement contract (V6): bundle/connector-pack roots are
+            # containers — their members get placed individually; the root
+            # itself produces no client artifacts.
+            return True
+        return self.install_skill(cap_name, version, source_dir, owner)
+
+    def remove_capability(self, cap_name: str, owner: str = "global", kind: str = "skill") -> bool:
+        if kind == "mcp-server":
+            return self.remove_mcp_server(cap_name, owner)
+        return self.remove_skill(cap_name, owner)
+
+    @abstractmethod
+    def install_skill(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        ...
+
+    @abstractmethod
+    def remove_skill(self, cap_name: str, owner: str = "global") -> bool:
+        ...
+
+    @abstractmethod
+    def install_mcp_server(self, cap_name: str, version: str, source_dir: Path, owner: str = "global") -> bool:
+        ...
+
+    @abstractmethod
+    def remove_mcp_server(self, cap_name: str, owner: str = "global") -> bool:
+        ...
+
+    @abstractmethod
+    def capability_exists(self, cap_name: str) -> bool:
+        ...