c2roo 1.0.0__py3-none-any.whl

c2roo/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

c2roo/cli.py

@@ -0,0 +1,277 @@
+import shutil
+import tempfile
+from pathlib import Path
+
+import click
+
+from c2roo.converter.agent_converter import convert_agent
+from c2roo.converter.command_converter import convert_command
+from c2roo.converter.hook_converter import convert_hooks
+from c2roo.converter.mcp_converter import convert_mcp
+from c2roo.converter.skill_converter import convert_skill
+from c2roo.parser.plugin_parser import parse_plugin
+from c2roo.report import ConversionReport
+from c2roo.sources.git_source import check_git_available, clone_repo, is_git_url
+from c2roo.sources.local_source import resolve_local
+from c2roo.sources.marketplace import MarketplaceRegistry
+from c2roo.writer.roo_writer import RooWriter
+
+
+def _resolve_output_root(target_global: bool) -> Path:
+    if target_global:
+        return Path.home() / ".roo"
+    return Path.cwd() / ".roo"
+
+
+def _run_conversion(plugin_path: Path, output_root: Path, force: bool, dry_run: bool) -> None:
+    """Shared parse -> convert -> write pipeline."""
+    plugin = parse_plugin(plugin_path)
+    writer = RooWriter(output_root=output_root, force=force, dry_run=dry_run)
+    report = ConversionReport(plugin_name=plugin.metadata.name)
+
+    for skill_ir in plugin.skills:
+        converted_skill = convert_skill(skill_ir)
+        source_dir = plugin_path / "skills" / skill_ir.name
+        writer.write_skill(converted_skill, source_dir)
+        report.add_skill(converted_skill.name, dropped=converted_skill.dropped_fields)
+
+    for cmd_ir in plugin.commands:
+        converted_cmd = convert_command(cmd_ir)
+        writer.write_command(converted_cmd)
+        report.add_command(converted_cmd.name, dropped=converted_cmd.dropped_fields)
+
+    for agent_ir in plugin.agents:
+        converted_agent = convert_agent(agent_ir)
+        writer.write_agent(converted_agent)
+        report.add_agent(agent_ir.name)
+
+    if plugin.hooks:
+        hooks_content = convert_hooks(plugin.hooks)
+        writer.write_hooks(hooks_content)
+        report.add_hooks(count=len(plugin.hooks))
+
+    if plugin.mcp_servers:
+        mcp_data = convert_mcp(plugin.mcp_servers, output_root)
+        writer.write_mcp(mcp_data)
+        report.add_mcp(count=len(plugin.mcp_servers))
+
+    report.print(str(output_root))
+
+
+@click.group()
+@click.version_option()
+def main() -> None:
+    """Convert Claude Code plugins to Roo Code format."""
+
+
+# --- marketplace subcommands ---
+
+
+@main.group()
+def marketplace() -> None:
+    """Browse and manage plugin marketplace sources."""
+
+
+@marketplace.command("browse")
+@click.option("--source", default=None, help="Filter to a specific marketplace source.")
+def marketplace_browse(source: str | None) -> None:
+    """List plugins from registered marketplaces."""
+    from rich.console import Console
+    from rich.table import Table
+
+    registry = MarketplaceRegistry()
+    sources = registry.list_sources()
+    if source:
+        sources = [s for s in sources if s["name"] == source]
+
+    console = Console()
+    table = Table(title="Available Plugins")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    table.add_column("Source", style="green")
+
+    for src in sources:
+        try:
+            plugins = registry.fetch_marketplace_json(src)
+            for plugin in plugins:
+                table.add_row(
+                    str(plugin.get("name", "?")),
+                    str(plugin.get("description", "")),
+                    src["name"],
+                )
+        except Exception as e:
+            console.print(f"[yellow]Warning: could not fetch {src['name']}: {e}[/yellow]")
+
+    console.print(table)
+
+
+@marketplace.command("add")
+@click.argument("repo")
+@click.option("--name", required=True, help="Short name for this marketplace.")
+@click.option("--description", default="", help="Description of this marketplace.")
+def marketplace_add(repo: str, name: str, description: str) -> None:
+    """Register a new marketplace source (owner/repo format)."""
+    registry = MarketplaceRegistry()
+    registry.add_source(name, repo, description)
+    click.echo(f"Added marketplace '{name}' ({repo})")
+
+
+@marketplace.command("list")
+def marketplace_list() -> None:
+    """Show registered marketplace sources."""
+    from rich.console import Console
+    from rich.table import Table
+
+    registry = MarketplaceRegistry()
+    sources = registry.list_sources()
+
+    console = Console()
+    table = Table(title="Registered Marketplaces")
+    table.add_column("Name", style="cyan")
+    table.add_column("Repo", style="green")
+    table.add_column("Description")
+
+    for src in sources:
+        table.add_row(src["name"], src.get("repo", ""), src.get("description", ""))
+
+    console.print(table)
+
+
+@marketplace.command("remove")
+@click.argument("name")
+def marketplace_remove(name: str) -> None:
+    """Remove a marketplace source."""
+    registry = MarketplaceRegistry()
+    registry.remove_source(name)
+    click.echo(f"Removed marketplace '{name}'")
+
+
+# --- convert command ---
+
+
+@main.command()
+@click.argument("source")
+@click.option(
+    "--global", "target_global", is_flag=True, default=False, help="Install to ~/.roo/ (global)."
+)
+@click.option(
+    "--project", "target_project", is_flag=True, default=False, help="Install to .roo/ (project)."
+)
+@click.option("--dry-run", is_flag=True, default=False, help="Show what would be converted.")
+@click.option("--force", is_flag=True, default=False, help="Overwrite existing files.")
+def convert(
+    source: str,
+    target_global: bool,
+    target_project: bool,
+    dry_run: bool,
+    force: bool,
+) -> None:
+    """Convert a Claude Code plugin from a local path or git URL."""
+    if not target_global and not target_project:
+        raise click.UsageError("Must specify --global or --project.")
+    if target_global and target_project:
+        raise click.UsageError("Cannot specify both --global and --project.")
+
+    temp_dir = None
+    if is_git_url(source):
+        check_git_available()
+        temp_dir = tempfile.mkdtemp(prefix="c2roo-")
+        plugin_path = clone_repo(source, dest=Path(temp_dir) / "plugin")
+    else:
+        plugin_path = resolve_local(source)
+
+    output_root = _resolve_output_root(target_global)
+
+    if dry_run:
+        click.echo("[DRY RUN] No files will be written.\n")
+
+    try:
+        _run_conversion(plugin_path, output_root, force, dry_run)
+    finally:
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+# --- install command ---
+
+
+@main.command()
+@click.argument("plugin_name")
+@click.option(
+    "--global", "target_global", is_flag=True, default=False, help="Install to ~/.roo/ (global)."
+)
+@click.option(
+    "--project", "target_project", is_flag=True, default=False, help="Install to .roo/ (project)."
+)
+@click.option("--source", default=None, help="Which marketplace to search.")
+@click.option("--dry-run", is_flag=True, default=False, help="Show what would be converted.")
+@click.option("--force", is_flag=True, default=False, help="Overwrite existing files.")
+def install(
+    plugin_name: str,
+    target_global: bool,
+    target_project: bool,
+    source: str | None,
+    dry_run: bool,
+    force: bool,
+) -> None:
+    """Install a plugin from a marketplace, converting to Roo format."""
+    if not target_global and not target_project:
+        raise click.UsageError("Must specify --global or --project.")
+    if target_global and target_project:
+        raise click.UsageError("Cannot specify both --global and --project.")
+
+    check_git_available()
+
+    registry = MarketplaceRegistry()
+    result = registry.search_plugin(plugin_name, source_filter=source)
+
+    if result is None:
+        raise click.ClickException(
+            f"Plugin '{plugin_name}' not found in any registered marketplace."
+        )
+
+    plugin_entry, mkt_source = result
+    click.echo(f"Found '{plugin_name}' in marketplace '{mkt_source['name']}'")
+
+    output_root = _resolve_output_root(target_global)
+
+    if dry_run:
+        click.echo("[DRY RUN] No files will be written.\n")
+
+    temp_dir = tempfile.mkdtemp(prefix="c2roo-")
+    try:
+        plugin_source = plugin_entry.get("source")
+
+        if isinstance(plugin_source, str):
+            # Relative path — clone the marketplace repo first
+            mkt_repo_url = f"https://github.com/{mkt_source['repo']}.git"
+            mkt_dir = Path(temp_dir) / "marketplace"
+            clone_repo(mkt_repo_url, dest=mkt_dir)
+            plugin_path = mkt_dir / plugin_source
+        elif isinstance(plugin_source, dict):
+            source_type = plugin_source.get("source")
+            if source_type == "url":
+                url = plugin_source["url"]
+                sha = plugin_source.get("sha")
+                plugin_path = clone_repo(url, dest=Path(temp_dir) / "plugin", sha=sha)
+            elif source_type == "git-subdir":
+                repo_url = plugin_source["url"]
+                if not repo_url.startswith("http"):
+                    repo_url = f"https://github.com/{repo_url}.git"
+                sha = plugin_source.get("sha")
+                subdir = plugin_source.get("path")
+                plugin_path = clone_repo(
+                    repo_url, dest=Path(temp_dir) / "plugin", sha=sha, subdir=subdir
+                )
+            else:
+                raise click.ClickException(f"Unknown source type: {source_type}")
+        else:
+            raise click.ClickException(f"Invalid source format for plugin '{plugin_name}'")
+
+        if not (plugin_path / ".claude-plugin" / "plugin.json").exists():
+            raise click.ClickException("Downloaded plugin has no .claude-plugin/plugin.json")
+
+        _run_conversion(plugin_path, output_root, force, dry_run)
+
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)

c2roo/converter/agent_converter.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+
+from c2roo.models.agent import Agent
+
+# Mapping from Claude Code tool names to Roo tool groups
+TOOL_TO_GROUP = {
+    "Read": "read",
+    "Grep": "read",
+    "Glob": "read",
+    "LS": "read",
+    "NotebookRead": "read",
+    "Write": "edit",
+    "Edit": "edit",
+    "MultiEdit": "edit",
+    "NotebookEdit": "edit",
+    "Bash": "command",
+    "BashOutput": "command",
+    "KillShell": "command",
+}
+
+MCP_TOOLS = {"WebFetch", "WebSearch", "TodoWrite"}
+
+
+def _humanize_name(slug: str) -> str:
+    """Convert kebab-case slug to Title Case name."""
+    return " ".join(word.capitalize() for word in slug.split("-"))
+
+
+def _extract_role_definition(body: str, max_length: int = 500) -> str:
+    """Extract the first paragraph of the body as a role definition."""
+    paragraphs = body.split("\n\n")
+    first = paragraphs[0].strip() if paragraphs else body.strip()
+    if len(first) > max_length:
+        first = first[:max_length].rsplit(" ", 1)[0] + "..."
+    return first
+
+
+def _map_tools_to_groups(tools: list[str]) -> list[str]:
+    """Map Claude Code tool names to Roo tool groups."""
+    groups = set()
+    for tool in tools:
+        if tool in TOOL_TO_GROUP:
+            groups.add(TOOL_TO_GROUP[tool])
+        elif tool in MCP_TOOLS:
+            groups.add("mcp")
+    return sorted(groups)
+
+
+@dataclass
+class ConvertedAgent:
+    mode: dict[str, object]
+    rules_content: str
+    slug: str
+
+
+def convert_agent(agent: Agent) -> ConvertedAgent:
+    """Convert an Agent IR to a Roo custom mode + rules file."""
+    slug = agent.name
+    groups = _map_tools_to_groups(agent.tools)
+
+    mode: dict[str, object] = {
+        "slug": slug,
+        "name": _humanize_name(slug),
+        "description": agent.description,
+        "roleDefinition": _extract_role_definition(agent.body),
+        "groups": groups,
+    }
+
+    lines = [
+        f"# {_humanize_name(slug)}",
+        "",
+        f"> Converted from Claude Code agent: `{agent.name}`",
+        "",
+        agent.body,
+    ]
+
+    footer_parts = []
+    if agent.model:
+        footer_parts.append(f"Originally configured for model: {agent.model}")
+    if agent.tools:
+        footer_parts.append(f"Original tool list: {', '.join(agent.tools)}")
+
+    if footer_parts:
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+        for part in footer_parts:
+            lines.append(f"*{part}*")
+
+    return ConvertedAgent(
+        mode=mode,
+        rules_content="\n".join(lines),
+        slug=slug,
+    )

c2roo/converter/command_converter.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field
+
+from c2roo.models.command import Command
+
+
+@dataclass
+class ConvertedCommand:
+    frontmatter: dict[str, object]
+    body: str
+    name: str
+    dropped_fields: list[str] = field(default_factory=list)
+
+
+def convert_command(cmd: Command) -> ConvertedCommand:
+    """Convert a Command IR to Roo slash command format."""
+    frontmatter: dict[str, object] = {}
+
+    if cmd.description:
+        frontmatter["description"] = cmd.description
+    if cmd.argument_hint:
+        frontmatter["argument-hint"] = cmd.argument_hint
+
+    dropped = []
+    if cmd.allowed_tools:
+        dropped.append("allowed-tools")
+
+    return ConvertedCommand(
+        frontmatter=frontmatter,
+        body=cmd.body,
+        name=cmd.name,
+        dropped_fields=sorted(dropped),
+    )

c2roo/converter/hook_converter.py

@@ -0,0 +1,43 @@
+from c2roo.models.hook import Hook
+
+
+def convert_hooks(hooks: list[Hook]) -> str:
+    """Convert Hook IRs to a Roo guidance rules markdown document."""
+    if not hooks:
+        return ""
+
+    lines = [
+        "# Converted from Claude Code hooks",
+        "",
+        "> These hooks were originally enforced automatically by Claude Code.",
+        "> Roo Code does not support hooks. The guidance below describes the",
+        "> original behavior — consider running these manually or setting up",
+        "> an equivalent workflow.",
+        "",
+    ]
+
+    # Group by event type
+    by_event: dict[str, list[Hook]] = {}
+    for hook in hooks:
+        by_event.setdefault(hook.event, []).append(hook)
+
+    for event, event_hooks in by_event.items():
+        lines.append(f"## {event}")
+        lines.append("")
+
+        for hook in event_hooks:
+            if hook.matcher:
+                lines.append(f"**Trigger:** when tools matching `{hook.matcher}` are used")
+                lines.append("")
+
+            lines.append("**Original command:**")
+            lines.append("```")
+            lines.append(hook.command)
+            lines.append("```")
+
+            if hook.timeout:
+                lines.append(f"*Timeout: {hook.timeout}s*")
+
+            lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"

c2roo/converter/mcp_converter.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+from c2roo.models.mcp import McpServer
+
+
+def _resolve_plugin_root(value: str, install_path: Path) -> str:
+    """Replace ${CLAUDE_PLUGIN_ROOT} with the actual install path."""
+    return value.replace("${CLAUDE_PLUGIN_ROOT}", str(install_path))
+
+
+def convert_mcp(servers: dict[str, McpServer], install_path: Path) -> dict[str, dict[str, object]]:
+    """Convert McpServer IRs to a Roo mcp.json-compatible dict."""
+    if not servers:
+        return {}
+
+    result: dict[str, dict[str, object]] = {}
+    for name, server in servers.items():
+        entry: dict[str, object] = {}
+
+        if server.command:
+            entry["command"] = _resolve_plugin_root(server.command, install_path)
+        if server.args:
+            entry["args"] = [_resolve_plugin_root(a, install_path) for a in server.args]
+        if server.env:
+            entry["env"] = {k: _resolve_plugin_root(v, install_path) for k, v in server.env.items()}
+        if server.url:
+            entry["url"] = server.url
+        if server.headers:
+            entry["headers"] = server.headers
+        if server.disabled:
+            entry["disabled"] = True
+        if server.always_allow:
+            entry["alwaysAllow"] = server.always_allow
+        if server.timeout:
+            entry["timeout"] = server.timeout
+
+        result[name] = entry
+
+    return result

c2roo/converter/skill_converter.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass, field
+
+from c2roo.models.skill import Skill
+
+CLAUDE_SPECIFIC_FIELDS = ["disable-model-invocation", "user-invocable", "context", "agent"]
+
+
+@dataclass
+class ConvertedSkill:
+    frontmatter: dict[str, object]
+    body: str
+    name: str
+    dropped_fields: list[str] = field(default_factory=list)
+
+
+def convert_skill(skill: Skill) -> ConvertedSkill:
+    """Convert a Skill IR to Roo skill format (cleaned frontmatter)."""
+    frontmatter: dict[str, object] = {
+        "name": skill.name,
+        "description": skill.description,
+    }
+
+    if skill.license:
+        frontmatter["license"] = skill.license
+    if skill.compatibility:
+        frontmatter["compatibility"] = skill.compatibility
+    if skill.metadata:
+        frontmatter["metadata"] = skill.metadata
+    if skill.allowed_tools:
+        frontmatter["allowed-tools"] = skill.allowed_tools
+
+    # Track which Claude-specific fields were present and dropped
+    dropped = []
+    if skill.agent is not None:
+        dropped.append("agent")
+    if skill.context is not None:
+        dropped.append("context")
+    if skill.disable_model_invocation is not None:
+        dropped.append("disable-model-invocation")
+    if skill.user_invocable is not None:
+        dropped.append("user-invocable")
+
+    return ConvertedSkill(
+        frontmatter=frontmatter,
+        body=skill.body,
+        name=skill.name,
+        dropped_fields=sorted(dropped),
+    )

c2roo/models/__init__.py

@@ -0,0 +1,16 @@
+from c2roo.models.agent import Agent
+from c2roo.models.command import Command
+from c2roo.models.hook import Hook
+from c2roo.models.mcp import McpServer
+from c2roo.models.plugin import Plugin, PluginMetadata
+from c2roo.models.skill import Skill
+
+__all__ = [
+    "Agent",
+    "Command",
+    "Hook",
+    "McpServer",
+    "Plugin",
+    "PluginMetadata",
+    "Skill",
+]

c2roo/models/agent.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Agent:
+    name: str
+    description: str
+    body: str
+    model: str | None = None
+    tools: list[str] = field(default_factory=list)
+    color: str | None = None

c2roo/models/command.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Command:
+    name: str
+    description: str | None = None
+    argument_hint: str | None = None
+    allowed_tools: str | None = None
+    body: str = ""

c2roo/models/hook.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Hook:
+    event: str
+    command: str
+    matcher: str | None = None
+    timeout: int | None = None

c2roo/models/mcp.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class McpServer:
+    name: str
+    command: str | None = None
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
+    url: str | None = None
+    headers: dict[str, str] = field(default_factory=dict)
+    disabled: bool = False
+    always_allow: list[str] = field(default_factory=list)
+    timeout: int | None = None

c2roo/models/plugin.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from c2roo.models.agent import Agent
+from c2roo.models.command import Command
+from c2roo.models.hook import Hook
+from c2roo.models.mcp import McpServer
+from c2roo.models.skill import Skill
+
+
+@dataclass
+class PluginMetadata:
+    name: str
+    description: str
+    version: str | None = None
+    author: str | None = None
+    homepage: str | None = None
+    license: str | None = None
+
+
+@dataclass
+class Plugin:
+    metadata: PluginMetadata
+    source_path: Path
+    skills: list[Skill] = field(default_factory=list)
+    commands: list[Command] = field(default_factory=list)
+    agents: list[Agent] = field(default_factory=list)
+    hooks: list[Hook] = field(default_factory=list)
+    mcp_servers: dict[str, McpServer] = field(default_factory=dict)

c2roo/models/skill.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Skill:
+    name: str
+    description: str
+    body: str
+    license: str | None = None
+    compatibility: str | None = None
+    metadata: dict[str, str] = field(default_factory=dict)
+    allowed_tools: str | None = None
+    resources: list[Path] = field(default_factory=list)
+    disable_model_invocation: bool | None = None
+    user_invocable: bool | None = None
+    context: str | None = None
+    agent: str | None = None

c2roo/parser/__init__.py

@@ -0,0 +1,3 @@
+from c2roo.parser.plugin_parser import parse_plugin
+
+__all__ = ["parse_plugin"]