lazyopencode 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lazyopencode/services/claude_code/parsers/skill.py

@@ -0,0 +1,130 @@
+"""Parser for Claude Code skill customizations."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    ConfigSource,
+    Customization,
+    CustomizationType,
+    SkillFile,
+    SkillMetadata,
+)
+from lazyopencode.services.parsers import parse_frontmatter
+
+if TYPE_CHECKING:
+    from lazyopencode.services.gitignore_filter import GitignoreFilter
+
+
+def _read_skill_files(
+    directory: Path,
+    exclude: set[str] | None = None,
+    gitignore_filter: "GitignoreFilter | None" = None,
+) -> list[SkillFile]:
+    """Recursively read all files in a skill directory."""
+    if exclude is None:
+        exclude = set()
+
+    files: list[SkillFile] = []
+    try:
+        entries = sorted(
+            directory.iterdir(), key=lambda p: (p.is_file(), p.name.lower())
+        )
+    except OSError:
+        return files
+
+    for entry in entries:
+        if entry.name in exclude or entry.name.startswith("."):
+            continue
+
+        if entry.is_dir():
+            if gitignore_filter and (
+                gitignore_filter.should_skip_dir(entry.name)
+                or gitignore_filter.is_dir_ignored(entry)
+            ):
+                continue
+
+            children = _read_skill_files(entry, exclude, gitignore_filter)
+            files.append(
+                SkillFile(
+                    name=entry.name,
+                    path=entry,
+                    is_directory=True,
+                    children=children,
+                )
+            )
+        elif entry.is_file():
+            try:
+                content = entry.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                content = None
+            files.append(
+                SkillFile(
+                    name=entry.name,
+                    path=entry,
+                    content=content,
+                )
+            )
+
+    return files
+
+
+class SkillParser:
+    """Parser for skill directories.
+
+    File pattern: skills/*/SKILL.md
+    """
+
+    def __init__(
+        self,
+        skills_dir: Path,
+        gitignore_filter: "GitignoreFilter | None" = None,
+    ) -> None:
+        """Initialize with the skills directory path."""
+        self.skills_dir = skills_dir
+        self._filter = gitignore_filter
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a SKILL.md file in a skill subdirectory."""
+        return path.name == "SKILL.md" and path.parent.parent == self.skills_dir
+
+    def parse(self, path: Path, level: ConfigLevel, source_level: str) -> Customization:
+        """Parse a skill SKILL.md file and detect directory contents."""
+        skill_dir = path.parent
+
+        try:
+            content = path.read_text(encoding="utf-8")
+        except OSError as e:
+            return Customization(
+                name=skill_dir.name,
+                type=CustomizationType.SKILL,
+                level=level,
+                path=path,
+                error=f"Failed to read file: {e}",
+                source=ConfigSource.CLAUDE_CODE,
+                source_level=source_level,
+            )
+
+        frontmatter, _ = parse_frontmatter(content)
+
+        name = frontmatter.get("name", skill_dir.name)
+        description = frontmatter.get("description")
+
+        skill_files = _read_skill_files(
+            skill_dir, exclude={"SKILL.md"}, gitignore_filter=self._filter
+        )
+
+        metadata = SkillMetadata(files=skill_files)
+
+        return Customization(
+            name=name,
+            type=CustomizationType.SKILL,
+            level=level,
+            path=path,
+            description=description,
+            content=content,
+            metadata=metadata.__dict__,
+            source=ConfigSource.CLAUDE_CODE,
+            source_level=source_level,
+        )

lazyopencode/services/claude_code/plugin_loader.py

@@ -0,0 +1,164 @@
+"""Plugin loading and registry management for Claude Code plugins."""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class PluginInstallation:
+    """Single installation of a plugin (user or project-scoped)."""
+
+    scope: str
+    install_path: str
+    version: str
+    is_local: bool = False
+    project_path: str | None = None
+
+
+@dataclass
+class PluginInfo:
+    """Information about an installed Claude Code plugin."""
+
+    plugin_id: str
+    short_name: str
+    version: str
+    install_path: Path
+    is_local: bool = False
+    scope: str = "user"
+    project_path: Path | None = None
+
+
+@dataclass
+class PluginRegistry:
+    """Container for installed plugin information."""
+
+    installed: dict[str, list[PluginInstallation]]
+
+
+class PluginLoader:
+    """Loads plugin configuration from the Claude Code filesystem."""
+
+    def __init__(
+        self,
+        user_config_path: Path,
+        project_root: Path | None = None,
+    ) -> None:
+        self.user_config_path = user_config_path
+        self.project_root = project_root
+        self._registry: PluginRegistry | None = None
+
+    def load_registry(self) -> PluginRegistry:
+        """Load installed plugins from configuration files."""
+        if self._registry is not None:
+            return self._registry
+
+        v2_file = self.user_config_path / "plugins" / "installed_plugins.json"
+        installed = self._load_v2_plugins(v2_file) if v2_file.is_file() else {}
+
+        self._registry = PluginRegistry(installed=installed)
+        return self._registry
+
+    def _load_v2_plugins(self, path: Path) -> dict[str, list[PluginInstallation]]:
+        """Parse V2 format where plugins value is a list."""
+        if not path.is_file():
+            return {}
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            plugins_data = data.get("plugins", {})
+            result: dict[str, list[PluginInstallation]] = {}
+
+            for plugin_id, installations in plugins_data.items():
+                result[plugin_id] = [
+                    PluginInstallation(
+                        scope=inst.get("scope", "user"),
+                        install_path=inst.get("installPath", ""),
+                        version=inst.get("version", "unknown"),
+                        is_local=inst.get("isLocal", False),
+                        project_path=inst.get("projectPath"),
+                    )
+                    for inst in installations
+                ]
+            return result
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def get_all_plugins(self) -> list[PluginInfo]:
+        """Get list of ALL plugin infos with resolved install paths."""
+        registry = self.load_registry()
+        plugins: list[PluginInfo] = []
+
+        for plugin_id, installations in registry.installed.items():
+            for installation in installations:
+                if (
+                    installation.scope == "user"
+                    or installation.scope == "project"
+                    and self._matches_current_project(installation.project_path)
+                ):
+                    plugin_info = self._create_plugin_info(plugin_id, installation)
+                    if plugin_info and plugin_info.install_path.is_dir():
+                        plugins.append(plugin_info)
+
+        return plugins
+
+    def _matches_current_project(self, project_path: str | None) -> bool:
+        """Check if project_path matches current project root."""
+        if not project_path or not self.project_root:
+            return False
+        try:
+            return Path(project_path).resolve() == self.project_root.resolve()
+        except OSError:
+            return False
+
+    def refresh(self) -> None:
+        """Clear cached registry to force reload."""
+        self._registry = None
+
+    def _create_plugin_info(
+        self,
+        plugin_id: str,
+        installation: PluginInstallation,
+    ) -> PluginInfo | None:
+        """Create PluginInfo from installation data."""
+        if not installation.install_path:
+            return None
+
+        short_name = plugin_id.split("@")[0] if "@" in plugin_id else plugin_id
+        install_path = Path(installation.install_path)
+        version = installation.version
+
+        if not install_path.is_dir() and install_path.parent.is_dir():
+            install_path = self._find_latest_version_dir(install_path.parent)
+            version = install_path.name
+
+        project_path = (
+            Path(installation.project_path) if installation.project_path else None
+        )
+
+        return PluginInfo(
+            plugin_id=plugin_id,
+            short_name=short_name,
+            version=version,
+            install_path=install_path,
+            is_local=installation.is_local,
+            scope=installation.scope,
+            project_path=project_path,
+        )
+
+    def _find_latest_version_dir(self, parent_dir: Path) -> Path:
+        """Find the latest version directory in a plugin parent directory."""
+        try:
+            subdirs = [d for d in parent_dir.iterdir() if d.is_dir()]
+            if subdirs:
+                return max(subdirs, key=lambda d: self._parse_version(d.name))
+        except OSError:
+            pass
+        return parent_dir
+
+    @staticmethod
+    def _parse_version(version_str: str) -> tuple[int, ...] | tuple[str]:
+        """Parse version string into comparable tuple."""
+        try:
+            return tuple(int(part) for part in version_str.split("."))
+        except ValueError:
+            return (version_str,)

lazyopencode/services/discovery.py

@@ -1,7 +1,10 @@
 """Configuration discovery service."""
 
+from __future__ import annotations
+
 import json
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from lazyopencode.models.customization import (
     ConfigLevel,
@@ -18,6 +21,9 @@ from lazyopencode.services.parsers.rules import RulesParser
 from lazyopencode.services.parsers.skill import SkillParser
 from lazyopencode.services.parsers.tool import ToolParser
 
+if TYPE_CHECKING:
+    from lazyopencode.services.claude_code.discovery import ClaudeCodeDiscoveryService
+
 
 class ConfigDiscoveryService:
     """Discovers OpenCode customizations from filesystem."""
@@ -26,6 +32,7 @@ class ConfigDiscoveryService:
         self,
         project_root: Path | None = None,
         global_config_path: Path | None = None,
+        enable_claude_code: bool = False,
     ) -> None:
         """
         Initialize discovery service.
@@ -33,11 +40,13 @@ class ConfigDiscoveryService:
         Args:
             project_root: Project root directory (defaults to cwd)
             global_config_path: Global config path (defaults to ~/.config/opencode)
+            enable_claude_code: Enable Claude Code customization discovery
         """
         self.project_root = project_root or Path.cwd()
         self.global_config_path = global_config_path or (
             Path.home() / ".config" / "opencode"
         )
+        self._enable_claude_code = enable_claude_code
         self._gitignore_filter = GitignoreFilter(project_root=self.project_root)
         self._parsers = {
             CustomizationType.COMMAND: CommandParser(),
@@ -51,6 +60,13 @@ class ConfigDiscoveryService:
             CustomizationType.PLUGIN: PluginParser(),
         }
         self._cache: list[Customization] | None = None
+        self._claude_code_discovery: ClaudeCodeDiscoveryService | None = None
+        if enable_claude_code:
+            from lazyopencode.services.claude_code.discovery import (
+                ClaudeCodeDiscoveryService,
+            )
+
+            self._claude_code_discovery = ClaudeCodeDiscoveryService(self.project_root)
 
     @property
     def project_config_path(self) -> Path:
@@ -75,16 +91,19 @@ class ConfigDiscoveryService:
         # Discover from project config
         customizations.extend(self._discover_level(ConfigLevel.PROJECT))
 
-        # De-duplicate by (type, name, level, resolved_path) tuple
+        # Discover Claude Code customizations (if enabled)
+        if self._claude_code_discovery:
+            customizations.extend(self._claude_code_discovery.discover_all())
+
+        # De-duplicate by (type, name, level, source, resolved_path) tuple
         # This avoids removing items that share a source file (like multiple
         # inline definitions from the same opencode.json)
         seen: set[tuple] = set()
         unique: list[Customization] = []
         for c in customizations:
             # Create a unique key for this customization
-            # For file-based items, use the resolved path
-            # For inline items, use (type, name, level) to avoid duplicates
-            key = (c.type, c.name, c.level, str(c.path.resolve()))
+            # Include source to allow same-named items from different sources
+            key = (c.type, c.name, c.level, c.source, str(c.path.resolve()))
             if key not in seen:
                 seen.add(key)
                 unique.append(c)
@@ -340,6 +359,8 @@ class ConfigDiscoveryService:
     def refresh(self) -> None:
         """Clear cache and force re-discovery."""
         self._cache = None
+        if self._claude_code_discovery:
+            self._claude_code_discovery.refresh()
 
     def by_type(self, ctype: CustomizationType) -> list[Customization]:
         """Get customizations filtered by type."""

lazyopencode/services/writer.py

@@ -0,0 +1,119 @@
+"""Service for writing customizations to OpenCode directories."""
+
+import shutil
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+
+
+class CustomizationWriter:
+    """Writes customizations to OpenCode configuration directories."""
+
+    def __init__(
+        self,
+        global_config_path: Path,
+        project_config_path: Path,
+    ) -> None:
+        """Initialize writer with config paths."""
+        self.global_config_path = global_config_path
+        self.project_config_path = project_config_path
+
+    def copy_customization(
+        self,
+        customization: Customization,
+        target_level: ConfigLevel,
+    ) -> tuple[bool, str]:
+        """
+        Copy customization to target level.
+
+        Args:
+            customization: The customization to copy
+            target_level: Target configuration level (GLOBAL or PROJECT)
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        try:
+            base_path = self._get_target_base_path(target_level)
+            target_path = self._build_target_path(customization, base_path)
+
+            if self._check_conflict(customization, target_path):
+                return (
+                    False,
+                    f"{customization.type_label} '{customization.name}' already exists at {target_level.label} level",
+                )
+
+            self._ensure_parent_dirs(target_path)
+
+            if customization.type == CustomizationType.SKILL:
+                self._copy_skill_directory(customization.path.parent, target_path)
+            else:
+                self._write_file(customization.path, target_path)
+
+            return (
+                True,
+                f"Copied '{customization.name}' to {target_level.label} level",
+            )
+
+        except PermissionError as e:
+            return (False, f"Permission denied writing to {e.filename}")
+        except OSError as e:
+            return (False, f"Failed to copy '{customization.name}': {e}")
+
+    def _get_target_base_path(self, level: ConfigLevel) -> Path:
+        """Get base path for target configuration level."""
+        if level == ConfigLevel.GLOBAL:
+            return self.global_config_path
+        elif level == ConfigLevel.PROJECT:
+            return self.project_config_path
+        else:
+            raise ValueError(f"Unsupported target level: {level}")
+
+    def _build_target_path(self, customization: Customization, base_path: Path) -> Path:
+        """Construct target file path based on customization type."""
+        if customization.type == CustomizationType.COMMAND:
+            # Handle nested commands (name:subname -> command/name/subname.md)
+            parts = customization.name.split(":")
+            if len(parts) > 1:
+                nested_path = Path(*parts[:-1])
+                filename = f"{parts[-1]}.md"
+                return base_path / "command" / nested_path / filename
+            else:
+                return base_path / "command" / f"{customization.name}.md"
+
+        elif customization.type == CustomizationType.AGENT:
+            return base_path / "agent" / f"{customization.name}.md"
+
+        elif customization.type == CustomizationType.SKILL:
+            return base_path / "skill" / customization.name
+
+        else:
+            raise ValueError(f"Unsupported customization type: {customization.type}")
+
+    def _check_conflict(self, customization: Customization, target_path: Path) -> bool:
+        """Check if target file or directory already exists."""
+        if customization.type == CustomizationType.SKILL:
+            return target_path.exists() and target_path.is_dir()
+        else:
+            return target_path.exists() and target_path.is_file()
+
+    def _ensure_parent_dirs(self, target_path: Path) -> None:
+        """Create parent directories if they don't exist."""
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _write_file(self, source_path: Path, target_path: Path) -> None:
+        """Copy file from source to target."""
+        content = source_path.read_text(encoding="utf-8")
+        target_path.write_text(content, encoding="utf-8")
+
+    def _copy_skill_directory(self, source_dir: Path, target_dir: Path) -> None:
+        """Copy entire skill directory tree."""
+        shutil.copytree(
+            source_dir,
+            target_dir,
+            dirs_exist_ok=False,
+        )

lazyopencode/widgets/app_footer.py

@@ -44,7 +44,7 @@ class AppFooter(Widget):
 
         return (
             f"[bold]q[/] Quit  [bold]?[/] Help  [bold]r[/] Refresh  "
-            f"[bold]e[/] Edit  "
+            f"[bold]e[/] Edit  [bold]c[/] Copy  "
             f"{all_key}  {user_key}  {project_key}  "
             f"{search_key}  │  [bold][$accent]^p[/][/] Palette"
         )

lazyopencode/widgets/level_selector.py

@@ -0,0 +1,130 @@
+"""Level selector bar for copy operations."""
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Static
+
+from lazyopencode.models.customization import ConfigLevel
+
+
+class LevelSelector(Widget):
+    """Bottom bar for selecting target configuration level."""
+
+    BINDINGS = [
+        Binding("1", "select_global", "Global", show=False),
+        Binding("2", "select_project", "Project", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    LevelSelector {
+        dock: bottom;
+        height: 3;
+        border: solid $accent;
+        padding: 0 1;
+        margin-bottom: 1;
+        display: none;
+        background: $surface;
+    }
+
+    LevelSelector.visible {
+        display: block;
+    }
+
+    LevelSelector:focus {
+        border: double $accent;
+    }
+
+    LevelSelector #prompt {
+        width: 100%;
+        text-align: center;
+    }
+
+    LevelSelector .key {
+        color: $accent;
+        text-style: bold;
+    }
+    """
+
+    can_focus = True
+
+    class LevelSelected(Message):
+        """Emitted when a level is selected."""
+
+        def __init__(self, level: ConfigLevel) -> None:
+            self.level = level
+            super().__init__()
+
+    class SelectionCancelled(Message):
+        """Emitted when selection is cancelled."""
+
+        pass
+
+    def __init__(
+        self,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize LevelSelector."""
+        super().__init__(name=name, id=id, classes=classes)
+        self._available_levels: list[ConfigLevel] = []
+        self._customization_name: str = ""
+
+    def compose(self) -> ComposeResult:
+        """Compose the level selector bar."""
+        yield Static("", id="prompt")
+
+    def show(
+        self,
+        available_levels: list[ConfigLevel],
+        customization_name: str = "",
+    ) -> None:
+        """Show the level selector and focus it."""
+        self._available_levels = available_levels
+        self._customization_name = customization_name
+        self._update_prompt()
+        self.add_class("visible")
+        self.focus()
+
+    def hide(self) -> None:
+        """Hide the level selector."""
+        self.remove_class("visible")
+
+    def _update_prompt(self) -> None:
+        """Update the prompt text based on available levels."""
+        name_part = f'"{self._customization_name}" ' if self._customization_name else ""
+
+        options = []
+        if ConfigLevel.GLOBAL in self._available_levels:
+            options.append("\\[1] Global")
+        if ConfigLevel.PROJECT in self._available_levels:
+            options.append("\\[2] Project")
+
+        options_text = "  ".join(options)
+        prompt_widget = self.query_one("#prompt", Static)
+        prompt_widget.update(f"Copy {name_part}to: {options_text}  \\[Esc] Cancel")
+
+    def action_select_global(self) -> None:
+        """Select global level."""
+        if ConfigLevel.GLOBAL in self._available_levels:
+            self.hide()
+            self.post_message(self.LevelSelected(ConfigLevel.GLOBAL))
+
+    def action_select_project(self) -> None:
+        """Select project level."""
+        if ConfigLevel.PROJECT in self._available_levels:
+            self.hide()
+            self.post_message(self.LevelSelected(ConfigLevel.PROJECT))
+
+    def action_cancel(self) -> None:
+        """Cancel selection."""
+        self.hide()
+        self.post_message(self.SelectionCancelled())
+
+    @property
+    def is_visible(self) -> bool:
+        """Check if the level selector is visible."""
+        return self.has_class("visible")

{lazyopencode-0.1.1.dist-info → lazyopencode-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazyopencode
-Version: 0.1.1
+Version: 0.2.0
 Summary: A lazygit-style TUI for visualizing OpenCode customizations
 Project-URL: Homepage, https://github.com/nikiforovall/lazyopencode
 Project-URL: Repository, https://github.com/nikiforovall/lazyopencode
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.11
 Requires-Dist: pathspec>=0.12.0
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: textual>=0.89.0