cc-plugin-to-codex 0.1.0__py3-none-any.whl

cc_plugin_to_codex/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("cc-plugin-to-codex")
+except PackageNotFoundError:
+    # Package not installed (e.g. running from source without `pip install -e .`).
+    __version__ = "0.0.0+unknown"

cc_plugin_to_codex/__main__.py

@@ -0,0 +1,4 @@
+from cc_plugin_to_codex.cli import app
+
+if __name__ == "__main__":
+    app()

cc_plugin_to_codex/agent_convert.py

@@ -0,0 +1,95 @@
+"""Convert CC agent markdown (YAML frontmatter + body) to Codex agent TOML."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+import yaml
+
+from cc_plugin_to_codex.bridge import build_agent_marker_line
+
+FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n(.*)$", re.DOTALL)
+
+# Codex-supported top-level fields we preserve from frontmatter if present
+_PASSTHROUGH_FIELDS = {"nickname_candidates"}
+
+# Fields we explicitly drop (not Codex-compatible)
+_DROPPED_FIELDS = {"model", "tools"}
+
+
+@dataclass
+class ConversionWarning:
+    field: str
+    reason: str
+
+
+@dataclass
+class ConversionResult:
+    agent_name: str
+    toml: str
+    warnings: list[ConversionWarning] = field(default_factory=list)
+
+
+def snake_case_name(s: str) -> str:
+    return s.replace("-", "_")
+
+
+def convert_agent(
+    md_path: Path,
+    *,
+    bridge_plugin: str,
+    source_plugin: str,
+    synced_at: str,
+) -> ConversionResult:
+    text = md_path.read_text(encoding="utf-8")
+    m = FRONTMATTER_RE.match(text)
+    if not m:
+        raise ValueError(f"{md_path}: no YAML frontmatter found")
+    fm_text, body = m.group(1), m.group(2).lstrip("\n")
+    frontmatter = yaml.safe_load(fm_text) or {}
+    if not isinstance(frontmatter, dict):
+        raise ValueError(f"{md_path}: frontmatter must be a YAML mapping")
+
+    source_agent = frontmatter.get("name")
+    if not source_agent:
+        raise ValueError(f"{md_path}: frontmatter missing required 'name'")
+
+    description = frontmatter.get("description") or f"Bridged from CC plugin {source_plugin}"
+
+    warnings: list[ConversionWarning] = []
+    for key in frontmatter:
+        if key in {"name", "description"} or key in _PASSTHROUGH_FIELDS:
+            continue
+        if key in _DROPPED_FIELDS:
+            warnings.append(ConversionWarning(field=key, reason="Not compatible with Codex"))
+        else:
+            warnings.append(
+                ConversionWarning(field=key, reason="Unknown frontmatter field, dropped")
+            )
+
+    agent_name = f"cc_{snake_case_name(source_plugin)}_{snake_case_name(source_agent)}"
+
+    toml_dict: dict[str, Any] = {
+        "name": agent_name,
+        "description": description,
+        "developer_instructions": body,
+    }
+    # passthrough fields
+    for key in _PASSTHROUGH_FIELDS:
+        if key in frontmatter:
+            toml_dict[key] = frontmatter[key]
+
+    toml_body = tomli_w.dumps(toml_dict)
+    marker_line = build_agent_marker_line(
+        source_plugin=source_plugin,
+        source_agent=source_agent,
+        bridge_plugin=bridge_plugin,
+        synced_at=synced_at,
+    )
+    full_toml = f"{marker_line}\n{toml_body}"
+
+    return ConversionResult(agent_name=agent_name, toml=full_toml, warnings=warnings)

cc_plugin_to_codex/bridge.py

@@ -0,0 +1,137 @@
+"""x-cc-bridge marker: plugin.json and agent TOML detection/creation."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Literal, TypedDict
+
+from cc_plugin_to_codex import __version__
+
+SourceKind = Literal["git", "local"]
+
+MARKER_KEY = "x-cc-bridge"
+TOOL_ID = f"cc-plugin-to-codex/{__version__}"
+
+
+class BridgeMarker(TypedDict):
+    sourcePlugin: str
+    source: str
+    sourceKind: SourceKind
+    ref: str | None
+    commit: str
+    marketplace: str
+    syncedAt: str
+    tool: str
+    agents: list[str]
+
+
+def build_marker(
+    *,
+    source_plugin: str,
+    source: str,
+    source_kind: SourceKind,
+    ref: str | None,
+    commit: str,
+    marketplace: str,
+    agents: list[str],
+    now: datetime | None = None,
+) -> BridgeMarker:
+    ts = (now or datetime.now(UTC)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    return BridgeMarker(
+        sourcePlugin=source_plugin,
+        source=source,
+        sourceKind=source_kind,
+        ref=ref,
+        commit=commit,
+        marketplace=marketplace,
+        syncedAt=ts,
+        tool=TOOL_ID,
+        agents=agents,
+    )
+
+
+_REQUIRED_BRIDGE_MARKER_KEYS = {
+    "sourcePlugin",
+    "source",
+    "sourceKind",
+    "ref",
+    "commit",
+    "marketplace",
+    "syncedAt",
+    "tool",
+    "agents",
+}
+
+
+def is_bridge_manifest(manifest: dict[str, Any]) -> bool:
+    return MARKER_KEY in manifest and isinstance(manifest[MARKER_KEY], dict)
+
+
+def extract_marker(manifest: dict[str, Any]) -> BridgeMarker | None:
+    """Return the bridge marker only if every required TypedDict field is present.
+
+    Silently returns None for a manifest with an incomplete or malformed marker
+    (e.g. `{"x-cc-bridge": {}}`), so callers can treat "bridge but unparseable"
+    the same as "not a bridge". Matches the stricter validation already done by
+    extract_agent_marker on the agent-TOML side.
+    """
+    if not is_bridge_manifest(manifest):
+        return None
+    payload = manifest[MARKER_KEY]
+    if not _REQUIRED_BRIDGE_MARKER_KEYS.issubset(payload.keys()):
+        return None
+    return payload
+
+
+# ---------------------------------------------------------------------------
+# Agent TOML first-line comment marker
+# ---------------------------------------------------------------------------
+
+AGENT_MARKER_REGEX = re.compile(r"^# x-cc-bridge: (\{.*\})$")
+
+
+class AgentMarker(TypedDict):
+    sourcePlugin: str
+    sourceAgent: str
+    bridgePlugin: str
+    syncedAt: str
+
+
+def build_agent_marker_line(
+    *,
+    source_plugin: str,
+    source_agent: str,
+    bridge_plugin: str,
+    synced_at: str,
+) -> str:
+    payload = {
+        "sourcePlugin": source_plugin,
+        "sourceAgent": source_agent,
+        "bridgePlugin": bridge_plugin,
+        "syncedAt": synced_at,
+    }
+    return f"# x-cc-bridge: {json.dumps(payload, separators=(',', ':'), ensure_ascii=False)}"
+
+
+def extract_agent_marker(toml_path: Path) -> AgentMarker | None:
+    if not toml_path.exists():
+        return None
+    try:
+        with toml_path.open("r", encoding="utf-8") as f:
+            first_line = f.readline().rstrip("\n")
+    except OSError:
+        return None
+    m = AGENT_MARKER_REGEX.match(first_line)
+    if not m:
+        return None
+    try:
+        payload = json.loads(m.group(1))
+    except json.JSONDecodeError:
+        return None
+    required = {"sourcePlugin", "sourceAgent", "bridgePlugin", "syncedAt"}
+    if not required.issubset(payload.keys()):
+        return None
+    return payload