kiro-cc-plugins 0.1.0__tar.gz

kiro_cc_plugins-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+uv.lock

kiro_cc_plugins-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: kiro-cc-plugins
+Version: 0.1.0
+Summary: Install Claude Code plugins into Kiro
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0

kiro_cc_plugins-0.1.0/README.md

@@ -0,0 +1,72 @@
+# kiro-cc-plugins
+
+Install [Claude Code plugins](https://code.claude.com/docs/en/plugins) into [Kiro](https://kiro.dev).
+
+Supports marketplace repos (like the [official Anthropic marketplace](https://github.com/anthropics/claude-plugins-official)) and standalone plugin/skill repos.
+
+## Install
+
+```bash
+# One-shot (no install needed)
+uvx --from git+https://github.com/anthropics/kiro-cc-plugins.git kiro-cc-plugins --help
+
+# Or install permanently
+uv tool install git+https://github.com/anthropics/kiro-cc-plugins.git
+```
+
+## Quick Start
+
+```bash
+# Add the official Claude Code marketplace
+kiro-cc-plugins source add https://github.com/anthropics/claude-plugins-official
+
+# Add the Anthropic skills repo
+kiro-cc-plugins source add https://github.com/anthropics/skills.git
+
+# Browse available plugins
+kiro-cc-plugins list
+
+# List all skills across sources
+kiro-cc-plugins list --skills
+
+# Install a plugin
+kiro-cc-plugins add feature-dev
+
+# Install to current project only
+kiro-cc-plugins add feature-dev --scope workspace
+
+# Install only specific component types
+kiro-cc-plugins add plugin-dev --only skill
+
+# Install from any git URL directly
+kiro-cc-plugins add --git https://github.com/user/my-cc-plugin
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `source add <url>` | Clone a marketplace or plugin repo |
+| `source list` | List registered sources |
+| `source update [name]` | Git pull sources |
+| `source remove <name>` | Remove a source |
+| `list [plugin]` | List available plugins or show plugin details |
+| `list --installed` | Show installed plugins |
+| `list --skills` | List all skills across sources |
+| `list --agents` | List all agents across sources |
+| `add <name>` | Convert and install a plugin |
+| `add --all` | Install all local plugins |
+| `add --scope workspace` | Install to `.kiro/` instead of `~/.kiro/` |
+| `update [name] / --all` | Re-sync from source and re-convert |
+| `delete <name> / --all` | Remove converted plugins |
+
+## Conversion Mapping
+
+| Claude Code | Kiro | Format |
+|---|---|---|
+| `skills/*/SKILL.md` | `~/.kiro/skills/{source}--{plugin}--{skill}/` | Direct copy (compatible format) |
+| `commands/*.md` | `~/.kiro/agents/{name}.json` | Prompt → agent JSON |
+| `agents/*.md` | `~/.kiro/agents/{name}.json` | Prompt → agent JSON, tools mapped |
+| `.mcp.json` | `~/.kiro/agents/{plugin}-mcp.json` | MCP config → agent with mcpServers |
+
+Hooks and LSP configs are skipped (no Kiro equivalent). Existing agents with the same name are not overwritten.

kiro_cc_plugins-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "kiro-cc-plugins"
+version = "0.1.0"
+description = "Install Claude Code plugins into Kiro"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+    "pyyaml>=6.0",
+]
+
+[project.scripts]
+kiro-cc-plugins = "kiro_cc_plugin_converter.cli:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kiro_cc_plugin_converter"]

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/__init__.py

@@ -0,0 +1 @@
+"""kiro-cc-plugin-converter: Convert Claude Code plugins to Kiro format."""

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/cli.py

@@ -0,0 +1,439 @@
+"""CLI entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from . import source as src_mod
+from . import scanner, converter, registry
+
+console = Console()
+
+
+# ── helpers ──────────────────────────────────────────────────────────────
+
+def _default_source() -> str | None:
+    sources = src_mod.list_sources()
+    if len(sources) == 1:
+        return sources[0]["name"]
+    return None
+
+
+def _resolve_source(source_name: str | None) -> str:
+    if source_name:
+        return source_name
+    default = _default_source()
+    if default:
+        return default
+    raise click.ClickException("Multiple sources found. Specify --source <name>.")
+
+
+def _find_plugin_source(plugin_name: str) -> tuple[str, list[dict]] | None:
+    """Search all sources for a plugin by name. Returns (source_name, plugins) or None."""
+    matches = []
+    for s in src_mod.list_sources():
+        try:
+            plugins = src_mod.parse_marketplace(s["name"])
+        except FileNotFoundError:
+            continue
+        if any(p["name"] == plugin_name for p in plugins):
+            matches.append((s["name"], plugins))
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        names = ", ".join(m[0] for m in matches)
+        raise click.ClickException(f"'{plugin_name}' found in multiple sources: {names}. Specify --source <name>.")
+    return None
+
+
+def _get_commit(source_name: str) -> str:
+    for s in src_mod.list_sources():
+        if s["name"] == source_name:
+            return s.get("commit", "")
+    return ""
+
+
+# ── source commands ──────────────────────────────────────────────────────
+
+@click.group()
+def cli():
+    """Convert Claude Code plugins to Kiro format."""
+
+
+@cli.group("source")
+def source_group():
+    """Manage plugin sources (git repos)."""
+
+
+@source_group.command("add")
+@click.argument("url")
+@click.option("--name", default=None, help="Override source name")
+def source_add(url: str, name: str | None):
+    """Clone a marketplace or plugin repo."""
+    with console.status(f"Cloning {url}..."):
+        s = src_mod.add_source(url, name)
+    console.print(f"[green]✓[/] Source [bold]{s.name}[/] added ({s.commit[:8]})")
+
+    plugins = src_mod.parse_marketplace(s.name)
+    local_count = sum(1 for p in plugins if p.get("_local_path"))
+    console.print(f"  {len(plugins)} plugins found, {local_count} available locally")
+
+
+@source_group.command("list")
+def source_list():
+    """List registered sources."""
+    sources = src_mod.list_sources()
+    if not sources:
+        console.print("[dim]No sources. Run: kiro-cc source add <url>[/]")
+        return
+    t = Table(title="Sources")
+    t.add_column("Name", style="bold")
+    t.add_column("URL")
+    t.add_column("Commit")
+    for s in sources:
+        t.add_row(s["name"], s["url"], s.get("commit", "")[:8])
+    console.print(t)
+
+
+@source_group.command("remove")
+@click.argument("name")
+def source_remove(name: str):
+    """Remove a source."""
+    src_mod.remove_source(name)
+    console.print(f"[green]✓[/] Source [bold]{name}[/] removed")
+
+
+@source_group.command("update")
+@click.argument("name", required=False)
+def source_update(name: str | None):
+    """Git pull a source."""
+    if name is None:
+        for s in src_mod.list_sources():
+            commit = src_mod.update_source(s["name"])
+            console.print(f"[green]✓[/] {s['name']} updated ({commit[:8]})")
+    else:
+        commit = src_mod.update_source(name)
+        console.print(f"[green]✓[/] {name} updated ({commit[:8]})")
+
+
+# ── list ─────────────────────────────────────────────────────────────────
+
+@cli.command("list")
+@click.argument("plugin_name", required=False)
+@click.option("--source", "source_name", default=None, help="Source name")
+@click.option("--installed", is_flag=True, help="Show installed plugins only")
+@click.option("--only", "only_types", default=None, help="Filter by type: skill,agent,command,mcp")
+@click.option("--skills", is_flag=True, help="List all skills across all sources")
+@click.option("--agents", is_flag=True, help="List all agents across all sources")
+def list_cmd(plugin_name: str | None, source_name: str | None, installed: bool, only_types: str | None, skills: bool, agents: bool):
+    """List available or installed plugins."""
+    type_filter = set(only_types.split(",")) if only_types else None
+
+    if skills or agents:
+        _list_all_components("skill" if skills else "agent", source_name)
+        return
+
+    if installed:
+        _list_installed(type_filter)
+        return
+
+    source_name = _resolve_source(source_name)
+    plugins = src_mod.parse_marketplace(source_name)
+
+    if plugin_name:
+        _show_plugin_detail(source_name, plugins, plugin_name, type_filter)
+    else:
+        _list_plugins(plugins, type_filter)
+
+
+def _list_all_components(comp_type: str, source_name: str | None):
+    """List all components of a given type across sources."""
+    sources = [{"name": source_name}] if source_name else src_mod.list_sources()
+    installed_targets = set()
+    for p in registry.get_installed():
+        for c in p.get("components", []):
+            installed_targets.add(c.get("name", ""))
+
+    label = comp_type.capitalize() + "s"
+    t = Table(title=f"All {label}")
+    t.add_column("Name", style="bold")
+    t.add_column("Plugin")
+    t.add_column("Source")
+    t.add_column("Description", max_width=45)
+    t.add_column("Status", justify="center")
+
+    total = 0
+    for src in sources:
+        sn = src["name"]
+        try:
+            plugins = src_mod.parse_marketplace(sn)
+        except FileNotFoundError:
+            continue
+        for plugin in plugins:
+            lp = plugin.get("_local_path")
+            if not lp or not Path(lp).is_dir():
+                continue
+            comps = scanner.scan_plugin(Path(lp), plugin.get("_skill_filter"))
+            for c in comps:
+                if c.type != comp_type:
+                    continue
+                status = "[green]✓[/]" if c.name in installed_targets else "[dim]○[/]"
+                desc = c.frontmatter.get("description", "")[:45]
+                t.add_row(c.name, plugin["name"], sn, desc, status)
+                total += 1
+
+    console.print(t)
+    console.print(f"\n[dim]{total} {comp_type}s found across local plugins.[/]")
+
+
+def _list_installed(type_filter: set | None):
+    items = registry.get_installed()
+    if not items:
+        console.print("[dim]No plugins installed.[/]")
+        return
+    t = Table(title="Installed Plugins")
+    t.add_column("Plugin", style="bold")
+    t.add_column("Source")
+    t.add_column("Components")
+    t.add_column("Installed")
+    for p in items:
+        comps = p.get("components", [])
+        if type_filter:
+            comps = [c for c in comps if c["type"] in type_filter]
+        summary = ", ".join(f"{c['type']}:{c['name']}" for c in comps)
+        t.add_row(p["plugin_name"], p["source_name"], summary, p.get("installed_at", "")[:10])
+    console.print(t)
+
+
+def _list_plugins(plugins: list[dict], type_filter: set | None):
+    installed_names = {p["plugin_name"] for p in registry.get_installed()}
+
+    t = Table(title="Available Plugins")
+    t.add_column("Name", style="bold")
+    t.add_column("Description", max_width=60)
+    t.add_column("Category")
+    t.add_column("Status", justify="center")
+
+    for p in plugins:
+        name = p["name"]
+        lp = p.get("_local_path")
+        if name in installed_names:
+            status = "[green]✓[/]"
+        elif lp and Path(lp).is_dir():
+            status = "[green]○[/]"
+        elif isinstance(p.get("source"), dict):
+            status = "[yellow]○[/]"
+        else:
+            status = "[red]✗[/]"
+        t.add_row(name, p.get("description", "")[:60], p.get("category", ""), status)
+    console.print(t)
+    installed_count = sum(1 for p in plugins if p["name"] in installed_names)
+    local_count = sum(1 for p in plugins if p.get("_local_path") and Path(p["_local_path"]).is_dir())
+    fetch_count = sum(1 for p in plugins if not (p.get("_local_path") and Path(p["_local_path"]).is_dir()) and isinstance(p.get("source"), dict))
+    console.print(f"\n[dim]{len(plugins)} plugins: [green]{installed_count} installed ✓[/], [green]{local_count} available ○[/], [yellow]{fetch_count} fetchable ○[/][/]")
+
+
+def _show_plugin_detail(source_name: str, plugins: list[dict], name: str, type_filter: set | None):
+    plugin = next((p for p in plugins if p["name"] == name), None)
+    if not plugin:
+        raise click.ClickException(f"Plugin '{name}' not found")
+
+    console.print(f"\n[bold]{name}[/]")
+    console.print(f"  {plugin.get('description', '')}")
+
+    local_path = plugin.get("_local_path")
+    if not local_path or not Path(local_path).is_dir():
+        src = plugin.get("source", "")
+        if isinstance(src, dict):
+            src_type = src.get("source", "")
+            src_detail = src.get("url", "") or src.get("repo", "")
+            console.print(f"\n  [dim]External ({src_type}): {src_detail}[/]")
+            console.print(f"  [dim]Run 'kiro-cc add {name}' to fetch and install.[/]")
+        else:
+            console.print(f"\n  [yellow]⚠ Not available locally[/]")
+        return
+
+    components = scanner.scan_plugin(Path(local_path), plugin.get("_skill_filter"))
+    if type_filter:
+        components = [c for c in components if c.type in type_filter]
+
+    if not components:
+        console.print("  [dim]No convertible components found.[/]")
+        return
+
+    t = Table()
+    t.add_column("Type", style="cyan")
+    t.add_column("Name", style="bold")
+    t.add_column("Description", max_width=50)
+    for c in components:
+        desc = c.frontmatter.get("description", "")[:50]
+        t.add_row(c.type, c.name, desc)
+    console.print(t)
+
+
+# ── add ──────────────────────────────────────────────────────────────────
+
+@cli.command("add")
+@click.argument("plugin_name", required=False)
+@click.option("--source", "source_name", default=None, help="Source name")
+@click.option("--all", "install_all", is_flag=True, help="Install all local plugins")
+@click.option("--only", "only_types", default=None, help="Filter: skill,agent,command,mcp")
+@click.option("--git", "git_url", default=None, help="Install from a git URL directly")
+@click.option("--scope", default="global", type=click.Choice(["global", "workspace"]), help="Install scope")
+def add_cmd(plugin_name: str | None, source_name: str | None, install_all: bool, only_types: str | None, git_url: str | None, scope: str):
+    """Convert and install plugins to ~/.kiro (global) or .kiro/ (workspace)."""
+    converter.set_scope(scope)
+    type_filter = set(only_types.split(",")) if only_types else None
+
+    if git_url:
+        s = src_mod.add_source(git_url)
+        source_name = s.name
+        install_all = True
+
+    # Auto-find source for a specific plugin name
+    if plugin_name and not source_name:
+        found = _find_plugin_source(plugin_name)
+        if found:
+            source_name, plugins = found
+        else:
+            source_name = _resolve_source(None)
+            plugins = src_mod.parse_marketplace(source_name)
+    else:
+        source_name = _resolve_source(source_name)
+        plugins = src_mod.parse_marketplace(source_name)
+
+    commit = _get_commit(source_name)
+
+    if install_all:
+        targets = [p for p in plugins if p.get("_local_path") and Path(p["_local_path"]).is_dir()]
+    elif plugin_name:
+        targets = [p for p in plugins if p["name"] == plugin_name]
+    else:
+        raise click.ClickException("Specify a plugin name or --all")
+
+    if not targets:
+        raise click.ClickException("No matching plugins found")
+
+    total_components = 0
+    for plugin in targets:
+        local_path = plugin.get("_local_path")
+
+        # Auto-fetch external plugins if not local yet
+        if (not local_path or not Path(local_path).is_dir()) and isinstance(plugin.get("source"), dict):
+            with console.status(f"Fetching {plugin['name']}..."):
+                fetched = src_mod.fetch_external_plugin(plugin["name"], plugin["source"])
+            if fetched and fetched.is_dir():
+                local_path = str(fetched)
+            else:
+                console.print(f"  [yellow]⚠ Failed to fetch {plugin['name']}[/]")
+                continue
+        elif not local_path or not Path(local_path).is_dir():
+            console.print(f"  [yellow]⚠ Skipping {plugin['name']} (not available)[/]")
+            continue
+
+        components = scanner.scan_plugin(Path(local_path), plugin.get("_skill_filter"))
+        if type_filter:
+            components = [c for c in components if c.type in type_filter]
+
+        if not components:
+            continue
+
+        converted = []
+        for comp in components:
+            conflict = converter.check_conflict(comp.name, comp.type, plugin["name"], source_name)
+            if conflict:
+                console.print(f"  [yellow]⚠ Skipping {comp.type}:{comp.name} — {conflict}[/]")
+                continue
+            result = converter.convert_component(comp, plugin["name"], source_name)
+            if result:
+                converted.append(result)
+                total_components += 1
+
+        if converted:
+            registry.add_installed(plugin["name"], source_name, converted, commit)
+            types_summary = ", ".join(sorted(set(c["type"] for c in converted)))
+            console.print(f"  [green]✓[/] {plugin['name']} → {len(converted)} components ({types_summary})")
+
+    target_dir = "~/.kiro/" if scope == "global" else ".kiro/"
+    console.print(f"\n[green]Done.[/] {total_components} components installed to {target_dir}")
+
+
+# ── delete ───────────────────────────────────────────────────────────────
+
+@cli.command("delete")
+@click.argument("plugin_name", required=False)
+@click.option("--all", "delete_all", is_flag=True, help="Delete all installed plugins")
+@click.confirmation_option(prompt="Are you sure?")
+def delete_cmd(plugin_name: str | None, delete_all: bool):
+    """Remove converted plugins from ~/.kiro."""
+    if delete_all:
+        targets = [p["plugin_name"] for p in registry.get_installed()]
+    elif plugin_name:
+        targets = [plugin_name]
+    else:
+        raise click.ClickException("Specify a plugin name or --all")
+
+    for name in targets:
+        components = registry.remove_installed(name)
+        for comp in components:
+            converter.remove_converted(comp["target_path"])
+        console.print(f"  [green]✓[/] {name} removed ({len(components)} components)")
+
+
+# ── update ───────────────────────────────────────────────────────────────
+
+@cli.command("update")
+@click.argument("plugin_name", required=False)
+@click.option("--all", "update_all", is_flag=True, help="Update all installed plugins")
+def update_cmd(plugin_name: str | None, update_all: bool):
+    """Re-sync from source and re-convert."""
+    installed = registry.get_installed()
+    if update_all:
+        targets = installed
+    elif plugin_name:
+        targets = [p for p in installed if p["plugin_name"] == plugin_name]
+    else:
+        raise click.ClickException("Specify a plugin name or --all")
+
+    if not targets:
+        raise click.ClickException("No matching installed plugins")
+
+    # Update sources
+    updated_sources = set()
+    for p in targets:
+        sn = p["source_name"]
+        if sn not in updated_sources:
+            with console.status(f"Updating source {sn}..."):
+                src_mod.update_source(sn)
+            updated_sources.add(sn)
+
+    # Re-convert
+    for p in targets:
+        sn = p["source_name"]
+        plugins = src_mod.parse_marketplace(sn)
+        plugin = next((pl for pl in plugins if pl["name"] == p["plugin_name"]), None)
+        if not plugin or not plugin.get("_local_path"):
+            console.print(f"  [yellow]⚠ {p['plugin_name']} not found in source[/]")
+            continue
+
+        # Remove old
+        for comp in p.get("components", []):
+            converter.remove_converted(comp["target_path"])
+
+        # Re-scan and convert
+        local_path = Path(plugin["_local_path"])
+        components = scanner.scan_plugin(local_path, plugin.get("_skill_filter"))
+        commit = _get_commit(sn)
+
+        converted = []
+        for comp in components:
+            result = converter.convert_component(comp, p["plugin_name"], sn)
+            if result:
+                converted.append(result)
+
+        registry.add_installed(p["plugin_name"], sn, converted, commit)
+        console.print(f"  [green]✓[/] {p['plugin_name']} updated ({len(converted)} components)")

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/converter.py

@@ -0,0 +1,213 @@
+"""Convert Claude Code plugin components to Kiro format."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from .models import KIRO_HOME, REGISTRY_FILE, load_json, kiro_root
+from .scanner import ScannedComponent
+
+_scope = "global"
+
+
+def set_scope(scope: str):
+    global _scope
+    _scope = scope
+
+
+def _kiro_agent_path(name: str) -> Path:
+    return kiro_root(_scope) / "agents" / f"{name}.json"
+
+
+def _kiro_skill_dir(name: str, plugin_name: str, source_name: str) -> Path:
+    safe_source = source_name.replace("/", "--")
+    return kiro_root(_scope) / "skills" / f"{safe_source}--{plugin_name}--{name}"
+
+
+def _is_ours(target: Path) -> bool:
+    """Check if an existing file was created by us (has [from cc:] marker)."""
+    if not target.exists():
+        return False
+    try:
+        d = json.loads(target.read_text())
+        return "[from cc:" in d.get("description", "")
+    except Exception:
+        return False
+
+
+def _is_our_skill(target_dir: Path) -> bool:
+    """Check if a skill dir was installed by us (in registry)."""
+    reg = load_json(REGISTRY_FILE, {"installed": []})
+    target_str = str(target_dir)
+    for p in reg.get("installed", []):
+        for c in p.get("components", []):
+            if target_str in c.get("target_path", ""):
+                return True
+    return False
+
+
+def check_conflict(name: str, comp_type: str, plugin_name: str = "", source_name: str = "") -> str | None:
+    """Return conflict message if target already exists and isn't ours. None if ok."""
+    if comp_type in ("agent", "command", "mcp"):
+        suffix = f"{name}-mcp" if comp_type == "mcp" else name
+        target = _kiro_agent_path(suffix)
+        if target.exists() and not _is_ours(target):
+            return f"Agent '{suffix}' already exists at {target}"
+    elif comp_type == "skill":
+        target = _kiro_skill_dir(name, plugin_name, source_name)
+        if target.is_dir() and not _is_our_skill(target):
+            return f"Skill '{name}' already exists at {target}"
+    return None
+
+
+def _map_tools(fm: dict) -> list[str]:
+    """Map Claude Code tool names to Kiro tool names."""
+    cc_tools = fm.get("tools", "")
+    if not cc_tools:
+        return ["*"]
+    if isinstance(cc_tools, str):
+        cc_tools = [t.strip() for t in cc_tools.split(",")]
+
+    mapping = {
+        "Read": "fs_read", "LS": "fs_read", "NotebookRead": "fs_read",
+        "Write": "fs_write", "Edit": "fs_write", "NotebookEdit": "fs_write", "TodoWrite": "fs_write",
+        "Glob": "glob", "Grep": "grep",
+        "Bash": "execute_bash", "BashOutput": "execute_bash", "KillShell": "execute_bash",
+        "Monitor": "execute_bash", "PowerShell": "execute_bash",
+        "WebFetch": "web_fetch", "WebSearch": "web_search",
+        "Agent": "use_subagent",
+        "LSP": "code",
+    }
+    kiro_tools = set()
+    for t in cc_tools:
+        base = t.split("(")[0].strip()
+        if base in mapping:
+            kiro_tools.add(mapping[base])
+        else:
+            kiro_tools.add(base.lower())
+    return sorted(kiro_tools) if kiro_tools else ["*"]
+
+
+def convert_agent(comp: ScannedComponent, plugin_name: str) -> dict:
+    """Convert a Claude Code agent .md to Kiro agent .json."""
+    fm = comp.frontmatter
+
+    desc = fm.get("description", "")
+    if not desc:
+        desc = f"[from cc:{plugin_name}]"
+    else:
+        desc = f"{desc} [from cc:{plugin_name}]"
+
+    agent_config = {
+        "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+        "name": comp.name,
+        "description": desc,
+        "prompt": comp.body.strip(),
+        "tools": _map_tools(fm),
+        "allowedTools": [],
+        "resources": [],
+        "hooks": {},
+        "toolsSettings": {},
+    }
+
+    if fm.get("model"):
+        model_map = {"opus": "claude-opus-4", "sonnet": "claude-sonnet-4", "haiku": "claude-haiku-3.5"}
+        agent_config["model"] = model_map.get(fm["model"], fm["model"])
+
+    target = _kiro_agent_path(comp.name)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(agent_config, indent=2, ensure_ascii=False) + "\n")
+    return {"type": comp.type, "name": comp.name, "source_rel": comp.rel_path, "target_path": str(target)}
+
+
+def convert_skill(comp: ScannedComponent, plugin_name: str, source_name: str = "") -> dict:
+    """Convert a Claude Code skill to Kiro skill (copy SKILL.md + supporting files)."""
+    target_dir = _kiro_skill_dir(comp.name, plugin_name, source_name)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    src_dir = comp.path.parent
+    for item in src_dir.iterdir():
+        dest = target_dir / item.name
+        if item.is_dir():
+            if dest.exists():
+                shutil.rmtree(dest)
+            shutil.copytree(item, dest)
+        else:
+            shutil.copy2(item, dest)
+
+    target = target_dir / "SKILL.md"
+    return {"type": "skill", "name": comp.name, "source_rel": comp.rel_path, "target_path": str(target)}
+
+
+def convert_command(comp: ScannedComponent, plugin_name: str) -> dict:
+    return convert_agent(comp, plugin_name)
+
+
+def convert_mcp(comp: ScannedComponent, plugin_name: str) -> dict:
+    mcp_data = comp.frontmatter
+    mcp_name = f"{plugin_name}-mcp"
+
+    agent_config = {
+        "$schema": "https://raw.githubusercontent.com/aws/amazon-q-developer-cli/refs/heads/main/schemas/agent-v1.json",
+        "name": mcp_name,
+        "description": f"MCP servers [from cc:{plugin_name}]",
+        "prompt": None,
+        "mcpServers": {},
+        "tools": ["*"],
+        "allowedTools": [],
+        "resources": [],
+        "hooks": {},
+        "toolsSettings": {},
+    }
+
+    for server_name, server_config in mcp_data.items():
+        kiro_server = {}
+        stype = server_config.get("type", "")
+        if stype in ("http", "streamable-http", "sse"):
+            kiro_server["type"] = "streamable-http" if stype == "http" else stype
+            kiro_server["url"] = server_config.get("url", "")
+        elif stype == "stdio":
+            kiro_server["type"] = "stdio"
+            kiro_server["command"] = server_config.get("command", "")
+            if server_config.get("args"):
+                kiro_server["args"] = server_config["args"]
+        else:
+            kiro_server = server_config
+        agent_config["mcpServers"][server_name] = kiro_server
+
+    target = _kiro_agent_path(mcp_name)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(agent_config, indent=2, ensure_ascii=False) + "\n")
+    return {"type": "mcp", "name": mcp_name, "source_rel": ".mcp.json", "target_path": str(target)}
+
+
+CONVERTERS = {
+    "skill": convert_skill,
+    "command": convert_command,
+    "agent": convert_agent,
+    "mcp": convert_mcp,
+}
+
+
+def convert_component(comp: ScannedComponent, plugin_name: str, source_name: str = "") -> dict | None:
+    converter = CONVERTERS.get(comp.type)
+    if converter:
+        if comp.type == "skill":
+            return converter(comp, plugin_name, source_name)
+        return converter(comp, plugin_name)
+    return None
+
+
+def remove_converted(target_path: str):
+    """Remove a converted file/directory. For skills, remove the whole skill dir."""
+    p = Path(target_path)
+    if p.is_dir():
+        shutil.rmtree(p)
+    elif p.exists():
+        parent = p.parent
+        p.unlink()
+        # If this was a SKILL.md inside a skill dir, remove the whole dir
+        if parent.parent == KIRO_HOME / "skills":
+            shutil.rmtree(parent, ignore_errors=True)

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/models.py

@@ -0,0 +1,57 @@
+"""Data models."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+
+KIRO_HOME = Path.home() / ".kiro"
+KIRO_WORKSPACE = Path(".kiro")
+CONVERTER_HOME = KIRO_HOME / "cc-plugins"
+CACHE_DIR = CONVERTER_HOME / "cache"
+CONFIG_FILE = CONVERTER_HOME / "config.json"
+REGISTRY_FILE = CONVERTER_HOME / "registry.json"
+
+
+def kiro_root(scope: str = "global") -> Path:
+    return KIRO_HOME if scope == "global" else KIRO_WORKSPACE
+
+CC_PREFIX = ""
+
+
+@dataclass
+class Source:
+    name: str
+    url: str
+    cloned_at: str = ""
+    commit: str = ""
+
+
+@dataclass
+class Component:
+    type: str  # skill, command, agent, mcp
+    name: str
+    source_rel: str  # relative path within plugin
+    target_path: str  # absolute path of converted file
+
+
+@dataclass
+class InstalledPlugin:
+    plugin_name: str
+    source_name: str
+    components: list[dict] = field(default_factory=list)
+    installed_at: str = ""
+    source_commit: str = ""
+
+
+def load_json(path: Path, default=None):
+    if path.exists():
+        return json.loads(path.read_text())
+    return default if default is not None else {}
+
+
+def save_json(path: Path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/registry.py

@@ -0,0 +1,55 @@
+"""Registry: track installed conversions."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from .models import REGISTRY_FILE, load_json, save_json
+
+
+def _load() -> dict:
+    return load_json(REGISTRY_FILE, {"installed": []})
+
+
+def _save(data: dict):
+    save_json(REGISTRY_FILE, data)
+
+
+def add_installed(plugin_name: str, source_name: str, components: list[dict], commit: str):
+    reg = _load()
+    reg["installed"] = [p for p in reg["installed"] if p["plugin_name"] != plugin_name]
+    reg["installed"].append({
+        "plugin_name": plugin_name,
+        "source_name": source_name,
+        "components": components,
+        "installed_at": datetime.now().isoformat(),
+        "source_commit": commit,
+    })
+    _save(reg)
+
+
+def remove_installed(plugin_name: str) -> list[dict]:
+    """Remove and return the plugin's components."""
+    reg = _load()
+    removed = []
+    remaining = []
+    for p in reg["installed"]:
+        if p["plugin_name"] == plugin_name:
+            removed = p.get("components", [])
+        else:
+            remaining.append(p)
+    reg["installed"] = remaining
+    _save(reg)
+    return removed
+
+
+def get_installed() -> list[dict]:
+    return _load().get("installed", [])
+
+
+def get_installed_plugin(name: str) -> dict | None:
+    for p in get_installed():
+        if p["plugin_name"] == name:
+            return p
+    return None

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/scanner.py

@@ -0,0 +1,122 @@
+"""Scan Claude Code plugin directories for convertible components."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class ScannedComponent:
+    type: str  # skill, command, agent, mcp
+    name: str
+    path: Path  # absolute path to the file
+    rel_path: str  # relative to plugin root
+    frontmatter: dict
+    body: str
+
+
+def _parse_frontmatter(text: str) -> tuple[dict, str]:
+    """Parse YAML frontmatter from markdown."""
+    import yaml
+
+    m = re.match(r"^---\s*\n(.*?)\n---\s*\n(.*)", text, re.DOTALL)
+    if not m:
+        return {}, text
+    try:
+        fm = yaml.safe_load(m.group(1)) or {}
+    except Exception:
+        fm = {}
+    return fm, m.group(2)
+
+
+def scan_plugin(plugin_dir: Path, skill_filter: list[str] | None = None) -> list[ScannedComponent]:
+    """Scan a Claude Code plugin directory for skills, commands, agents, mcp.
+    
+    skill_filter: if set, only include skills whose relative dirs match (e.g. ["./skills/pdf"]).
+    """
+    if not plugin_dir.is_dir():
+        return []
+
+    # Normalize skill_filter to a set of absolute paths
+    allowed_skill_dirs: set[str] | None = None
+    if skill_filter:
+        allowed_skill_dirs = set()
+        for sf in skill_filter:
+            p = (plugin_dir / sf.lstrip("./")).resolve()
+            allowed_skill_dirs.add(str(p))
+
+    components = []
+
+    # Skills: skills/*/SKILL.md
+    skills_dir = plugin_dir / "skills"
+    if skills_dir.is_dir():
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            if allowed_skill_dirs and str(skill_dir.resolve()) not in allowed_skill_dirs:
+                continue
+            skill_md = skill_dir / "SKILL.md"
+            if skill_md.exists():
+                text = skill_md.read_text()
+                fm, body = _parse_frontmatter(text)
+                # Collect supporting files
+                components.append(ScannedComponent(
+                    type="skill",
+                    name=fm.get("name", skill_dir.name),
+                    path=skill_md,
+                    rel_path=str(skill_md.relative_to(plugin_dir)),
+                    frontmatter=fm,
+                    body=body,
+                ))
+
+    # Commands: commands/*.md
+    cmds_dir = plugin_dir / "commands"
+    if cmds_dir.is_dir():
+        for md in cmds_dir.glob("*.md"):
+            text = md.read_text()
+            fm, body = _parse_frontmatter(text)
+            components.append(ScannedComponent(
+                type="command",
+                name=fm.get("name", md.stem),
+                path=md,
+                rel_path=str(md.relative_to(plugin_dir)),
+                frontmatter=fm,
+                body=body,
+            ))
+
+    # Agents: agents/*.md
+    agents_dir = plugin_dir / "agents"
+    if agents_dir.is_dir():
+        for md in agents_dir.glob("*.md"):
+            text = md.read_text()
+            fm, body = _parse_frontmatter(text)
+            components.append(ScannedComponent(
+                type="agent",
+                name=fm.get("name", md.stem),
+                path=md,
+                rel_path=str(md.relative_to(plugin_dir)),
+                frontmatter=fm,
+                body=body,
+            ))
+
+    # MCP: .mcp.json
+    mcp_file = plugin_dir / ".mcp.json"
+    if mcp_file.exists():
+        import json
+
+        try:
+            mcp_data = json.loads(mcp_file.read_text())
+            components.append(ScannedComponent(
+                type="mcp",
+                name="mcp",
+                path=mcp_file,
+                rel_path=".mcp.json",
+                frontmatter=mcp_data,
+                body="",
+            ))
+        except Exception:
+            pass
+
+    return components

kiro_cc_plugins-0.1.0/src/kiro_cc_plugin_converter/source.py

@@ -0,0 +1,220 @@
+"""Git source management and marketplace parsing."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+from .models import CACHE_DIR, CONFIG_FILE, Source, load_json, save_json
+
+def _cache_dir_for(name: str) -> Path:
+    """Map source name (e.g. 'anthropics/skills') to a cache directory."""
+    return CACHE_DIR / name.replace("/", "--")
+
+
+EXTERNAL_CACHE = CACHE_DIR / "_external"
+
+
+def _run(cmd: list[str], cwd: str | Path | None = None) -> str:
+    r = subprocess.run(cmd, capture_output=True, text=True, cwd=cwd)
+    if r.returncode != 0:
+        raise RuntimeError(f"Command failed: {' '.join(cmd)}\n{r.stderr}")
+    return r.stdout.strip()
+
+
+def _get_commit(repo_dir: Path) -> str:
+    return _run(["git", "rev-parse", "HEAD"], cwd=repo_dir)
+
+
+def add_source(url: str, name: str | None = None) -> Source:
+    """Clone a marketplace/plugin repo and register it."""
+    if name is None:
+        # Extract owner/repo from URL
+        path = url.rstrip("/").rstrip(".git")
+        parts = path.split("/")
+        if len(parts) >= 2:
+            name = f"{parts[-2]}/{parts[-1]}"
+        else:
+            name = parts[-1]
+
+    repo_dir = _cache_dir_for(name)
+    if repo_dir.exists():
+        _run(["git", "pull", "--ff-only"], cwd=repo_dir)
+    else:
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        _run(["git", "clone", "--depth", "1", url, str(repo_dir)])
+
+    src = Source(name=name, url=url, cloned_at=datetime.now().isoformat(), commit=_get_commit(repo_dir))
+
+    config = load_json(CONFIG_FILE, {"sources": []})
+    config["sources"] = [s for s in config["sources"] if s["name"] != name]
+    config["sources"].append({"name": src.name, "url": src.url, "cloned_at": src.cloned_at, "commit": src.commit})
+    save_json(CONFIG_FILE, config)
+    return src
+
+
+def update_source(name: str) -> str:
+    """Git pull a cached source, return new commit."""
+    repo_dir = _cache_dir_for(name)
+    if not repo_dir.exists():
+        raise FileNotFoundError(f"Source '{name}' not found in cache")
+    _run(["git", "pull", "--ff-only"], cwd=repo_dir)
+    commit = _get_commit(repo_dir)
+
+    config = load_json(CONFIG_FILE, {"sources": []})
+    for s in config["sources"]:
+        if s["name"] == name:
+            s["commit"] = commit
+    save_json(CONFIG_FILE, config)
+    return commit
+
+
+def remove_source(name: str):
+    """Remove a cached source."""
+    repo_dir = _cache_dir_for(name)
+    if repo_dir.exists():
+        shutil.rmtree(repo_dir)
+    config = load_json(CONFIG_FILE, {"sources": []})
+    config["sources"] = [s for s in config["sources"] if s["name"] != name]
+    save_json(CONFIG_FILE, config)
+
+
+def list_sources() -> list[dict]:
+    return load_json(CONFIG_FILE, {"sources": []}).get("sources", [])
+
+
+def get_source_dir(name: str) -> Path:
+    d = _cache_dir_for(name)
+    if not d.exists():
+        raise FileNotFoundError(f"Source '{name}' not cached. Run: kiro-cc source add <url>")
+    return d
+
+
+# ── external plugin fetching ─────────────────────────────────────────────
+
+def _normalize_git_url(url: str) -> str:
+    """Ensure url is a full git clone URL."""
+    if url.startswith(("http://", "https://", "git@")):
+        return url
+    # shorthand like "owner/repo" → github https
+    return f"https://github.com/{url}.git"
+
+
+def fetch_external_plugin(plugin_name: str, source_spec: dict) -> Path | None:
+    """Clone an external plugin and return its local path."""
+    EXTERNAL_CACHE.mkdir(parents=True, exist_ok=True)
+    dest = EXTERNAL_CACHE / plugin_name
+
+    src_type = source_spec.get("source", "") if isinstance(source_spec, dict) else ""
+
+    if src_type == "url":
+        url = _normalize_git_url(source_spec["url"])
+        ref = source_spec.get("ref")
+        sha = source_spec.get("sha")
+        return _clone_or_pull(dest, url, ref=ref, sha=sha)
+
+    elif src_type == "github":
+        repo = source_spec["repo"]
+        url = f"https://github.com/{repo}.git"
+        ref = source_spec.get("ref")
+        sha = source_spec.get("sha")
+        return _clone_or_pull(dest, url, ref=ref, sha=sha)
+
+    elif src_type == "git-subdir":
+        url = _normalize_git_url(source_spec["url"])
+        subpath = source_spec.get("path", "")
+        ref = source_spec.get("ref")
+        sha = source_spec.get("sha")
+        repo_dir = _clone_or_pull(dest, url, ref=ref, sha=sha)
+        if repo_dir and subpath:
+            full = repo_dir / subpath
+            return full if full.is_dir() else None
+        return repo_dir
+
+    return None
+
+
+def _clone_or_pull(dest: Path, url: str, ref: str | None = None, sha: str | None = None) -> Path | None:
+    """Clone (or pull) a repo to dest. Optionally checkout ref/sha."""
+    try:
+        if dest.exists():
+            _run(["git", "fetch", "--depth", "1", "origin"], cwd=dest)
+            if sha:
+                _run(["git", "fetch", "--depth", "1", "origin", sha], cwd=dest)
+                _run(["git", "checkout", sha], cwd=dest)
+            elif ref:
+                _run(["git", "checkout", f"origin/{ref}"], cwd=dest)
+            else:
+                _run(["git", "pull", "--ff-only"], cwd=dest)
+        else:
+            cmd = ["git", "clone", "--depth", "1"]
+            if ref and not sha:
+                cmd += ["--branch", ref]
+            cmd += [url, str(dest)]
+            _run(cmd)
+            if sha:
+                _run(["git", "fetch", "--depth", "1", "origin", sha], cwd=dest)
+                _run(["git", "checkout", sha], cwd=dest)
+        return dest
+    except RuntimeError:
+        return None
+
+
+# ── marketplace parsing ──────────────────────────────────────────────────
+
+def parse_marketplace(source_name: str) -> list[dict]:
+    """Parse marketplace.json and return plugin entries with resolved local paths."""
+    repo_dir = get_source_dir(source_name)
+    mp_file = repo_dir / ".claude-plugin" / "marketplace.json"
+
+    if not mp_file.exists():
+        # Treat as single plugin
+        pj = repo_dir / ".claude-plugin" / "plugin.json"
+        name = source_name
+        desc = ""
+        if pj.exists():
+            d = json.loads(pj.read_text())
+            name = d.get("name", source_name)
+            desc = d.get("description", "")
+        return [{"name": name, "description": desc, "source": ".", "_local_path": str(repo_dir)}]
+
+    mp = json.loads(mp_file.read_text())
+    plugins = []
+    for entry in mp.get("plugins", []):
+        src = entry.get("source", "")
+        local_path = None
+
+        if isinstance(src, str) and src.startswith("."):
+            local_path = str(repo_dir / src.lstrip("./"))
+        elif isinstance(src, dict):
+            # Check if already fetched
+            ext_path = _resolve_external_cached(entry["name"], src)
+            if ext_path:
+                local_path = str(ext_path)
+
+        plugins.append({
+            "name": entry.get("name", ""),
+            "description": entry.get("description", ""),
+            "category": entry.get("category", ""),
+            "source": src,
+            "_local_path": local_path,
+            "_skill_filter": entry.get("skills"),  # e.g. ["./skills/pdf", "./skills/xlsx"]
+        })
+    return plugins
+
+
+def _resolve_external_cached(plugin_name: str, source_spec: dict) -> Path | None:
+    """Check if an external plugin is already cached."""
+    dest = EXTERNAL_CACHE / plugin_name
+    if not dest.is_dir():
+        return None
+    src_type = source_spec.get("source", "")
+    if src_type == "git-subdir":
+        subpath = source_spec.get("path", "")
+        if subpath:
+            full = dest / subpath
+            return full if full.is_dir() else None
+    return dest