llmcode-cli 1.0.0__py3-none-any.whl

llm_code/marketplace/builtin_registry.py

@@ -0,0 +1,102 @@
+"""Built-in registry of known Claude Code plugins (official + community)."""
+from __future__ import annotations
+
+OFFICIAL_PLUGINS = [
+    {"name": "superpowers", "desc": "Core skills: TDD, debugging, collaboration, plans", "skills": 28, "repo": "obra/superpowers"},
+    {"name": "data-engineering", "desc": "Data warehouse exploration, pipeline audit, SQL", "skills": 46, "repo": ""},
+    {"name": "searchfit-seo", "desc": "AI-powered SEO toolkit — audit, content strategy", "skills": 22, "repo": ""},
+    {"name": "chrome-devtools-mcp", "desc": "Browser automation, debugging, performance analysis", "skills": 8, "repo": "anthropics/claude-code-chrome-devtools-mcp"},
+    {"name": "figma", "desc": "Figma MCP server + design-to-code skills", "skills": 7, "repo": ""},
+    {"name": "frontend-design", "desc": "UI/UX implementation skill for web frontends", "skills": 3, "repo": ""},
+    {"name": "skill-creator", "desc": "Create, improve, and measure skill performance", "skills": 3, "repo": ""},
+    {"name": "remember", "desc": "Continuous memory — extract and persist context", "skills": 2, "repo": ""},
+    {"name": "claude-code-setup", "desc": "Analyze codebases, recommend Claude Code automations", "skills": 1, "repo": ""},
+    {"name": "claude-md-management", "desc": "Audit and improve CLAUDE.md files", "skills": 1, "repo": ""},
+    {"name": "agent-sdk-dev", "desc": "Claude Agent SDK development tools", "skills": 0, "repo": ""},
+    {"name": "code-review", "desc": "Automated code review with specialized agents", "skills": 0, "repo": ""},
+    {"name": "code-simplifier", "desc": "Simplify and refine code for clarity", "skills": 0, "repo": ""},
+    {"name": "commit-commands", "desc": "Streamline git workflow — commit, push, PR", "skills": 0, "repo": ""},
+    {"name": "context7", "desc": "Context7 MCP for up-to-date documentation lookup", "skills": 0, "repo": ""},
+    {"name": "explanatory-output-style", "desc": "Educational insights about implementation choices", "skills": 0, "repo": ""},
+    {"name": "feature-dev", "desc": "Feature development workflow with specialized agents", "skills": 0, "repo": ""},
+    {"name": "playwright", "desc": "Browser automation and E2E testing (Microsoft)", "skills": 0, "repo": ""},
+    {"name": "pr-review-toolkit", "desc": "Comprehensive PR review with specialized agents", "skills": 0, "repo": ""},
+    {"name": "ralph-loop", "desc": "Continuous self-referential AI loops", "skills": 0, "repo": ""},
+    {"name": "security-guidance", "desc": "Security reminder hooks for safe coding", "skills": 0, "repo": ""},
+    {"name": "semgrep", "desc": "Semgrep MCP for static analysis and SAST", "skills": 0, "repo": ""},
+    {"name": "supabase", "desc": "Supabase MCP for database and auth operations", "skills": 0, "repo": ""},
+    {"name": "clangd-lsp", "desc": "C/C++ language server integration", "skills": 0, "repo": ""},
+    {"name": "gopls-lsp", "desc": "Go language server integration", "skills": 0, "repo": ""},
+    {"name": "pyright-lsp", "desc": "Python language server integration", "skills": 0, "repo": ""},
+    {"name": "rust-analyzer-lsp", "desc": "Rust language server integration", "skills": 0, "repo": ""},
+    {"name": "typescript-lsp", "desc": "TypeScript language server integration", "skills": 0, "repo": ""},
+]
+
+COMMUNITY_PLUGINS = [
+    {"name": "ai-integration-architect", "desc": "Design and scaffold AI integration into enterprise systems", "skills": 1, "repo": ""},
+    {"name": "claude-md-optimizer", "desc": "Optimize oversized CLAUDE.md using progressive disclosure", "skills": 1, "repo": ""},
+]
+
+
+def get_all_known_plugins() -> list[dict]:
+    """Return all known plugins (official + community) sorted by skill count."""
+    all_plugins = []
+    for p in OFFICIAL_PLUGINS:
+        all_plugins.append({**p, "source": "official"})
+    for p in COMMUNITY_PLUGINS:
+        all_plugins.append({**p, "source": "community"})
+    all_plugins.sort(key=lambda x: (-x["skills"], x["name"]))
+    return all_plugins
+
+
+async def search_clawhub_skills(query: str = "", limit: int = 30) -> list[tuple[str, str]]:
+    """Search ClawHub.ai skill marketplace (44,000+ skills)."""
+    import httpx
+
+    # If no query, fetch popular categories to get a good mix
+    queries = [query] if query else ["code", "test", "review", "debug", "deploy", "security", "api", "frontend"]
+
+    results: list[tuple[str, str]] = []
+    seen_slugs: set[str] = set()
+
+    async with httpx.AsyncClient(timeout=8.0) as client:
+        for q in queries:
+            if len(results) >= limit:
+                break
+            try:
+                resp = await client.get(
+                    "https://clawhub.ai/api/search",
+                    params={"q": q, "limit": min(10, limit - len(results))},
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                for item in data.get("results", []):
+                    slug = item.get("slug", "")
+                    if slug and slug not in seen_slugs:
+                        seen_slugs.add(slug)
+                        name = item.get("displayName") or slug
+                        summary = item.get("summary", "")[:60]
+                        results.append((slug, f"{name} — {summary}"))
+            except Exception:
+                continue
+
+    return results[:limit]
+
+
+async def search_clawhub_plugins(query: str, limit: int = 30) -> list[tuple[str, str]]:
+    """Search ClawHub.ai plugin marketplace."""
+    import httpx
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        resp = await client.get(
+            "https://clawhub.ai/api/search",
+            params={"q": f"plugin {query}", "limit": limit},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    results = []
+    for item in data.get("results", []):
+        name = item.get("displayName") or item.get("slug", "")
+        slug = item.get("slug", "")
+        summary = item.get("summary", "")[:70]
+        results.append((slug, f"{name} — {summary}"))
+    return results

llm_code/marketplace/installer.py

@@ -0,0 +1,162 @@
+"""Plugin installer — local copy, npm, and GitHub install strategies."""
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+from llm_code.marketplace.plugin import InstalledPlugin, PluginManifest
+
+
+# State file format:
+# {
+#   "plugin-name": {"enabled": true, "installed_from": "local"}
+# }
+
+
+class PluginInstaller:
+    """Manages installation, removal, and enumeration of plugins."""
+
+    def __init__(self, install_dir: Path) -> None:
+        self._install_dir = install_dir
+        self._install_dir.mkdir(parents=True, exist_ok=True)
+        self._state_path = self._install_dir / "state.json"
+
+    # ------------------------------------------------------------------
+    # State helpers
+    # ------------------------------------------------------------------
+
+    def _read_state(self) -> dict[str, dict[str, Any]]:
+        if not self._state_path.exists():
+            return {}
+        return json.loads(self._state_path.read_text(encoding="utf-8"))
+
+    def _write_state(self, state: dict[str, dict[str, Any]]) -> None:
+        self._state_path.write_text(json.dumps(state, indent=2), encoding="utf-8")
+
+    # ------------------------------------------------------------------
+    # Install strategies
+    # ------------------------------------------------------------------
+
+    def install_from_local(self, source: Path) -> Path:
+        """Copy a local plugin directory into the install directory.
+
+        Returns the destination path.
+        """
+        manifest = PluginManifest.from_path(source)
+        dest = self._install_dir / manifest.name
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(source, dest)
+
+        state = self._read_state()
+        state[manifest.name] = {"enabled": True, "installed_from": "local"}
+        self._write_state(state)
+
+        return dest
+
+    async def install_from_npm(self, package: str, version: str = "latest") -> Path:
+        """Install a plugin package via npm --prefix (uses execvp, not shell).
+
+        Returns the destination path.
+        """
+        dest = self._install_dir / package.replace("/", "__")
+        dest.mkdir(parents=True, exist_ok=True)
+        pkg_spec = f"{package}@{version}" if version != "latest" else package
+
+        proc = await asyncio.create_subprocess_exec(
+            "npm", "install", "--prefix", str(dest), pkg_spec,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.communicate()
+
+        state = self._read_state()
+        state[package] = {"enabled": True, "installed_from": "npm"}
+        self._write_state(state)
+
+        return dest
+
+    async def install_from_github(self, repo: str, ref: str = "main") -> Path:
+        """Clone a GitHub repository as a plugin using git clone (uses execvp, not shell).
+
+        Returns the destination path.
+        """
+        name = repo.replace("/", "__")
+        dest = self._install_dir / name
+        if dest.exists():
+            shutil.rmtree(dest)
+
+        url = f"https://github.com/{repo}.git"
+        proc = await asyncio.create_subprocess_exec(
+            "git", "clone", "--depth", "1", "--branch", ref, url, str(dest),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.communicate()
+
+        state = self._read_state()
+        state[name] = {"enabled": True, "installed_from": "github"}
+        self._write_state(state)
+
+        return dest
+
+    # ------------------------------------------------------------------
+    # Management
+    # ------------------------------------------------------------------
+
+    def uninstall(self, name: str) -> None:
+        """Remove an installed plugin by name."""
+        dest = self._install_dir / name
+        if dest.exists():
+            shutil.rmtree(dest)
+
+        state = self._read_state()
+        state.pop(name, None)
+        self._write_state(state)
+
+    def list_installed(self) -> list[InstalledPlugin]:
+        """Return all installed plugins, merging directory scan with state.json."""
+        state = self._read_state()
+        plugins: list[InstalledPlugin] = []
+
+        for entry in sorted(self._install_dir.iterdir()):
+            if not entry.is_dir():
+                continue
+            if entry.name == "state.json":
+                continue
+            try:
+                manifest = PluginManifest.from_path(entry)
+            except FileNotFoundError:
+                continue
+
+            entry_state = state.get(manifest.name, {})
+            enabled = bool(entry_state.get("enabled", True))
+            installed_from = str(entry_state.get("installed_from", "local"))
+
+            plugins.append(
+                InstalledPlugin(
+                    manifest=manifest,
+                    path=entry,
+                    enabled=enabled,
+                    installed_from=installed_from,
+                )
+            )
+
+        return plugins
+
+    def enable(self, name: str) -> None:
+        """Mark a plugin as enabled in state.json."""
+        state = self._read_state()
+        entry = state.setdefault(name, {})
+        state[name] = {**entry, "enabled": True}
+        self._write_state(state)
+
+    def disable(self, name: str) -> None:
+        """Mark a plugin as disabled in state.json."""
+        state = self._read_state()
+        entry = state.setdefault(name, {})
+        state[name] = {**entry, "enabled": False}
+        self._write_state(state)

llm_code/marketplace/plugin.py

@@ -0,0 +1,78 @@
+"""Plugin manifest and installed-plugin models for the marketplace subsystem."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PluginManifest:
+    """Immutable representation of a parsed .claude-plugin/plugin.json manifest."""
+
+    name: str
+    version: str
+    description: str
+    author: dict[str, Any] | None = None
+    homepage: str | None = None
+    repository: str | None = None
+    keywords: tuple[str, ...] = ()
+    commands: tuple[str, ...] = ()
+    agents: tuple[str, ...] | None = None
+    skills: str | tuple[str, ...] | None = None
+    hooks: dict[str, Any] | None = None
+    mcp_servers: tuple[dict[str, Any], ...] | None = None
+    lsp_servers: tuple[dict[str, Any], ...] | None = None
+
+    @classmethod
+    def from_path(cls, plugin_dir: Path) -> "PluginManifest":
+        """Read .claude-plugin/plugin.json from plugin_dir and return a PluginManifest.
+
+        Raises FileNotFoundError if plugin_dir does not exist or plugin.json is missing.
+        """
+        if not plugin_dir.exists():
+            raise FileNotFoundError(f"Plugin directory not found: {plugin_dir}")
+
+        manifest_path = plugin_dir / ".claude-plugin" / "plugin.json"
+        if not manifest_path.exists():
+            raise FileNotFoundError(f"Plugin manifest not found: {manifest_path}")
+
+        data: dict[str, Any] = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+        # Map camelCase JSON keys to snake_case fields
+        mcp_raw = data.get("mcpServers")
+        lsp_raw = data.get("lspServers")
+
+        keywords_raw = data.get("keywords", [])
+        commands_raw = data.get("commands", [])
+        agents_raw = data.get("agents")
+        skills_raw = data.get("skills")
+        hooks_raw = data.get("hooks")
+
+        return cls(
+            name=data["name"],
+            version=data["version"],
+            description=data["description"],
+            author=data.get("author"),
+            homepage=data.get("homepage"),
+            repository=data.get("repository"),
+            keywords=tuple(keywords_raw) if keywords_raw else (),
+            commands=tuple(commands_raw) if commands_raw else (),
+            agents=tuple(agents_raw) if agents_raw is not None else None,
+            skills=skills_raw if isinstance(skills_raw, str) else (tuple(skills_raw) if skills_raw is not None else None),
+            hooks=hooks_raw,
+            mcp_servers=tuple(mcp_raw) if mcp_raw is not None else None,
+            lsp_servers=tuple(lsp_raw) if lsp_raw is not None else None,
+        )
+
+
+@dataclass(frozen=True)
+class InstalledPlugin:
+    """Immutable snapshot of an installed plugin with runtime state."""
+
+    manifest: PluginManifest
+    path: Path
+    enabled: bool
+    scope: str = "user"
+    installed_from: str = "local"