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

lazyopencode/__init__.py

@@ -38,11 +38,22 @@ def main() -> None:
         help="Override user config path (default: ~/.config/opencode)",
     )
 
+    parser.add_argument(
+        "--claude-code",
+        action="store_true",
+        default=False,
+        help="Enable Claude Code customizations discovery (from ~/.claude/)",
+    )
+
     args = parser.parse_args()
 
     # Handle directory argument - resolve to absolute path
     project_root = args.directory.resolve() if args.directory else None
     user_config = args.user_config.resolve() if args.user_config else None
 
-    app = create_app(project_root=project_root, global_config_path=user_config)
+    app = create_app(
+        project_root=project_root,
+        global_config_path=user_config,
+        enable_claude_code=args.claude_code,
+    )
     app.run()

lazyopencode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

lazyopencode/app.py

@@ -16,6 +16,7 @@ from lazyopencode.mixins.help import HelpMixin
 from lazyopencode.mixins.navigation import NavigationMixin
 from lazyopencode.models.customization import (
     ConfigLevel,
+    ConfigSource,
     Customization,
     CustomizationType,
 )
@@ -23,8 +24,10 @@ from lazyopencode.services.discovery import ConfigDiscoveryService
 from lazyopencode.themes import CUSTOM_THEMES
 from lazyopencode.widgets.app_footer import AppFooter
 from lazyopencode.widgets.combined_panel import CombinedPanel
+from lazyopencode.widgets.delete_confirm import DeleteConfirm
 from lazyopencode.widgets.detail_pane import MainPane
 from lazyopencode.widgets.filter_input import FilterInput
+from lazyopencode.widgets.level_selector import LevelSelector
 from lazyopencode.widgets.status_panel import StatusPanel
 from lazyopencode.widgets.type_panel import TypePanel
 
@@ -44,6 +47,7 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         discovery_service: ConfigDiscoveryService | None = None,
         project_root: Path | None = None,
         global_config_path: Path | None = None,
+        enable_claude_code: bool = False,
     ) -> None:
         """Initialize LazyOpenCode application."""
         super().__init__()
@@ -51,6 +55,7 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         self._discovery_service = discovery_service or ConfigDiscoveryService(
             project_root=project_root,
             global_config_path=global_config_path,
+            enable_claude_code=enable_claude_code,
         )
         self._customizations: list[Customization] = []
         self._level_filter: ConfigLevel | None = None
@@ -60,7 +65,10 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         self._main_pane: MainPane | None = None
         self._filter_input: FilterInput | None = None
         self._app_footer: AppFooter | None = None
+        self._level_selector: LevelSelector | None = None
+        self._delete_confirm: DeleteConfirm | None = None
         self._last_focused_panel: TypePanel | CombinedPanel | None = None
+        self._pending_customization: Customization | None = None
 
     def compose(self) -> ComposeResult:
         """Compose the application layout."""
@@ -105,6 +113,12 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         self._filter_input = FilterInput(id="filter-input")
         yield self._filter_input
 
+        self._level_selector = LevelSelector(id="level-selector")
+        yield self._level_selector
+
+        self._delete_confirm = DeleteConfirm(id="delete-confirm")
+        yield self._delete_confirm
+
         self._app_footer = AppFooter(id="app-footer")
         yield self._app_footer
 
@@ -153,7 +167,12 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         """Get customizations filtered by current level and search query."""
         result = self._customizations
         if self._level_filter:
-            result = [c for c in result if c.level == self._level_filter]
+            # When filtering by level, only show OpenCode items (exclude Claude Code)
+            result = [
+                c
+                for c in result
+                if c.level == self._level_filter and c.source == ConfigSource.OPENCODE
+            ]
         if self._search_query:
             query = self._search_query.lower()
             result = [c for c in result if query in c.name.lower()]
@@ -167,6 +186,7 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         """Handle selection change in a type panel."""
         if self._main_pane:
             self._main_pane.customization = message.customization
+        self._update_footer_can_delete(message.customization)
 
     def on_type_panel_drill_down(self, message: TypePanel.DrillDown) -> None:
         """Handle drill down into a customization."""
@@ -188,6 +208,7 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         """Handle selection change in the combined panel."""
         if self._main_pane:
             self._main_pane.customization = message.customization
+        self._update_footer_can_delete(message.customization)
 
     def on_combined_panel_drill_down(self, message: CombinedPanel.DrillDown) -> None:
         """Handle drill down from the combined panel."""
@@ -253,7 +274,6 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         """Refresh customizations from disk."""
         self._discovery_service.refresh()
         self._load_customizations()
-        self.notify("Refreshed", severity="information")
 
     # action_toggle_help handled by HelpMixin
 
@@ -296,14 +316,187 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         except Exception as e:
             self.notify(f"Error opening editor: {e}", severity="error")
 
+    # Copy actions
+
+    def action_copy_customization(self) -> None:
+        """Copy selected customization to another level."""
+        panel = self._get_focused_panel()
+        customization = None
+
+        if panel:
+            customization = panel.selected_customization
+
+        if not customization:
+            self.notify("No customization selected", severity="warning")
+            return
+
+        # Only allow copying commands, agents, and skills
+        copyable_types = (
+            CustomizationType.COMMAND,
+            CustomizationType.AGENT,
+            CustomizationType.SKILL,
+        )
+        if customization.type not in copyable_types:
+            self.notify(
+                f"Cannot copy {customization.type_label} customizations",
+                severity="warning",
+            )
+            return
+
+        available = customization.get_copy_targets()
+        if not available:
+            self.notify("No available target levels", severity="warning")
+            return
+
+        self._pending_customization = customization
+        self._last_focused_panel = panel
+        if self._level_selector:
+            self._level_selector.show(available, customization.name)
+
+    def action_copy_path_to_clipboard(self) -> None:
+        """Copy path of selected customization to clipboard."""
+        panel = self._get_focused_panel()
+        customization = None
+
+        if panel:
+            customization = panel.selected_customization
+
+        if not customization:
+            self.notify("No customization selected", severity="warning")
+            return
+
+        file_path = customization.path
+        if customization.type == CustomizationType.SKILL:
+            file_path = customization.path.parent
+
+        try:
+            import pyperclip
+
+            pyperclip.copy(str(file_path))
+            self.notify(f"Copied: {file_path}", severity="information")
+        except ImportError:
+            self.notify(
+                "pyperclip not installed. Run: pip install pyperclip",
+                severity="error",
+            )
+        except Exception as e:
+            self.notify(f"Failed to copy to clipboard: {e}", severity="error")
+
+    # Level selector message handlers
+
+    def on_level_selector_level_selected(
+        self, message: LevelSelector.LevelSelected
+    ) -> None:
+        """Handle level selection from the level selector."""
+        if self._pending_customization:
+            self._handle_copy(self._pending_customization, message.level)
+            self._pending_customization = None
+        self._restore_focus_after_selector()
+
+    def on_level_selector_selection_cancelled(
+        self,
+        message: LevelSelector.SelectionCancelled,  # noqa: ARG002
+    ) -> None:
+        """Handle level selector cancellation."""
+        self._pending_customization = None
+        self._restore_focus_after_selector()
+
+    def _handle_copy(
+        self, customization: Customization, target_level: ConfigLevel
+    ) -> None:
+        """Handle copy operation."""
+        from lazyopencode.services.writer import CustomizationWriter
+
+        writer = CustomizationWriter(
+            global_config_path=self._discovery_service.global_config_path,
+            project_config_path=self._discovery_service.project_config_path,
+        )
+
+        success, msg = writer.copy_customization(customization, target_level)
+
+        if success:
+            self.notify(msg, severity="information")
+            self.action_refresh()
+        else:
+            self.notify(msg, severity="error")
+
+    def _restore_focus_after_selector(self) -> None:
+        """Restore focus to the previously focused panel."""
+        if self._last_focused_panel:
+            self._last_focused_panel.focus()
+        elif self._panels:
+            self._panels[0].focus()
+
+    def _update_footer_can_delete(self, customization: Customization | None) -> None:
+        """Update footer delete indicator based on current selection."""
+        if self._app_footer:
+            self._app_footer.can_delete = (
+                customization is not None and customization.is_deletable()
+            )
+
+    # Delete actions
+
+    def action_delete_customization(self) -> None:
+        """Delete selected customization."""
+        panel = self._get_focused_panel()
+        customization = panel.selected_customization if panel else None
+
+        if not customization:
+            self.notify("No customization selected", severity="warning")
+            return
+
+        if not customization.is_deletable():
+            self.notify(
+                f"Cannot delete {customization.type_label} customizations",
+                severity="warning",
+            )
+            return
+
+        self._last_focused_panel = panel
+        if self._delete_confirm:
+            self._delete_confirm.show(customization)
+
+    def on_delete_confirm_delete_confirmed(
+        self, message: DeleteConfirm.DeleteConfirmed
+    ) -> None:
+        """Handle delete confirmation."""
+        from lazyopencode.services.writer import CustomizationWriter
+
+        writer = CustomizationWriter(
+            global_config_path=self._discovery_service.global_config_path,
+            project_config_path=self._discovery_service.project_config_path,
+        )
+
+        success, msg = writer.delete_customization(message.customization)
+
+        if success:
+            self.notify(msg, severity="information")
+            self.action_refresh()
+        else:
+            self.notify(msg, severity="error")
+
+        self._restore_focus_after_selector()
+
+    def on_delete_confirm_delete_cancelled(
+        self,
+        message: DeleteConfirm.DeleteCancelled,  # noqa: ARG002
+    ) -> None:
+        """Handle delete cancellation."""
+        self._restore_focus_after_selector()
+
 
 def create_app(
     project_root: Path | None = None,
     global_config_path: Path | None = None,
+    enable_claude_code: bool = False,
 ) -> LazyOpenCode:
     """Create application with all dependencies wired."""
     discovery_service = ConfigDiscoveryService(
         project_root=project_root,
         global_config_path=global_config_path,
+        enable_claude_code=enable_claude_code,
+    )
+    return LazyOpenCode(
+        discovery_service=discovery_service,
+        enable_claude_code=enable_claude_code,
     )
-    return LazyOpenCode(discovery_service=discovery_service)

lazyopencode/bindings.py

@@ -7,6 +7,9 @@ APP_BINDINGS: list[BindingType] = [
     Binding("?", "toggle_help", "Help"),
     Binding("r", "refresh", "Refresh"),
     Binding("e", "open_in_editor", "Edit"),
+    Binding("c", "copy_customization", "Copy"),
+    Binding("d", "delete_customization", "Delete"),
+    Binding("C", "copy_path_to_clipboard", "Copy Path", key_display="shift+c"),
     Binding("ctrl+u", "open_user_config", "User Config"),
     Binding("tab", "focus_next_panel", "Next Panel", show=False),
     Binding("shift+tab", "focus_previous_panel", "Prev Panel", show=False),

lazyopencode/mixins/help.py

@@ -50,6 +50,8 @@ class HelpMixin:
                  Combined: switch tabs
 
 [bold]Actions[/]
+  c              Copy to level (modal)
+  C (shift+c)    Copy path to clipboard
   e              Open in $EDITOR
   ctrl+u         Open User Config
   r              Refresh from disk

lazyopencode/models/customization.py

@@ -43,6 +43,13 @@ class ConfigLevel(Enum):
         return "G" if self == ConfigLevel.GLOBAL else "P"
 
 
+class ConfigSource(Enum):
+    """Source of customization configuration."""
+
+    OPENCODE = "opencode"  # Native OpenCode customizations
+    CLAUDE_CODE = "claude"  # Imported from Claude Code paths
+
+
 class CustomizationType(Enum):
     """Type of OpenCode customization."""
 
@@ -93,6 +100,8 @@ class Customization:
     content: str | None = None
     metadata: dict[str, Any] = field(default_factory=dict)
     error: str | None = None
+    source: ConfigSource = ConfigSource.OPENCODE
+    source_level: str | None = None  # "user", "project", "plugin" for Claude Code
 
     @property
     def type_label(self) -> str:
@@ -105,16 +114,49 @@ class Customization:
         return self.level.label
 
     @property
-    def level_icon(self) -> str:
-        """Level icon for compact display."""
-        return self.level.icon
+    def level_icon(self) -> str | None:
+        """Level icon for compact display. Returns None for OpenCode items."""
+        if self.source == ConfigSource.CLAUDE_CODE:
+            return "👾"
+        return None
 
     @property
     def display_name(self) -> str:
         """Formatted name for display with level indicator."""
-        return f"[{self.level_icon}] {self.name}"
+        icon = self.level_icon
+        parts = []
+        if icon:
+            parts.append(f"[{icon}]")
+        parts.append(self.name)
+
+        # Add dimmed plugin name for plugin-sourced items
+        if self.source_level and self.source_level.startswith("plugin:"):
+            plugin_name = self.source_level.replace("plugin:", "")
+            parts.append(f"[dim]{plugin_name}[/dim]")
+
+        return " ".join(parts)
 
     @property
     def has_error(self) -> bool:
         """Check if this customization has a parse error."""
         return self.error is not None
+
+    def get_copy_targets(self) -> list[ConfigLevel]:
+        """Get valid copy target levels for this item."""
+        if self.source == ConfigSource.CLAUDE_CODE:
+            return [ConfigLevel.GLOBAL, ConfigLevel.PROJECT]
+        elif self.level == ConfigLevel.GLOBAL:
+            return [ConfigLevel.PROJECT]
+        else:
+            return [ConfigLevel.GLOBAL]
+
+    def is_deletable(self) -> bool:
+        """Check if this customization can be deleted."""
+        if self.source != ConfigSource.OPENCODE:
+            return False
+        deletable_types = (
+            CustomizationType.COMMAND,
+            CustomizationType.AGENT,
+            CustomizationType.SKILL,
+        )
+        return self.type in deletable_types

lazyopencode/services/claude_code/__init__.py

@@ -0,0 +1,9 @@
+"""Claude Code integration layer for LazyOpenCode.
+
+This module provides discovery of Claude Code customizations from standard
+Claude Code paths (~/.claude/, ./.claude/, plugins).
+"""
+
+from lazyopencode.services.claude_code.discovery import ClaudeCodeDiscoveryService
+
+__all__ = ["ClaudeCodeDiscoveryService"]

lazyopencode/services/claude_code/discovery.py

@@ -0,0 +1,158 @@
+"""Service for discovering Claude Code customizations."""
+
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+)
+from lazyopencode.services.claude_code.parsers.agent import AgentParser
+from lazyopencode.services.claude_code.parsers.command import CommandParser
+from lazyopencode.services.claude_code.parsers.skill import SkillParser
+from lazyopencode.services.claude_code.plugin_loader import PluginLoader
+from lazyopencode.services.gitignore_filter import GitignoreFilter
+
+
+class ClaudeCodeDiscoveryService:
+    """Discovers Claude Code customizations from standard Claude Code paths.
+
+    This is a separate layer responsible for Claude Code integration.
+
+    Discovery paths:
+    - User: ~/.claude/
+    - Project: ./.claude/
+    - Plugins: ~/.claude/plugins/ (via plugin registry)
+    """
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self.user_path = Path.home() / ".claude"
+        self.plugins_path = self.user_path / "plugins"
+        self._gitignore_filter = GitignoreFilter(project_root=project_root)
+        self._plugin_loader = PluginLoader(
+            user_config_path=self.user_path,
+            project_root=project_root,
+        )
+
+    def discover_all(self) -> list[Customization]:
+        """Discover all Claude Code customizations."""
+        customizations: list[Customization] = []
+
+        # User-level
+        customizations.extend(self._discover_from_path(self.user_path, "user"))
+
+        # Project-level
+        project_claude = self.project_root / ".claude"
+        customizations.extend(self._discover_from_path(project_claude, "project"))
+
+        # Plugin-level (using plugin registry)
+        customizations.extend(self._discover_from_plugins())
+
+        return customizations
+
+    def _discover_from_path(self, base: Path, source_level: str) -> list[Customization]:
+        """Discover commands, agents, skills from a Claude Code path."""
+        if not base.exists():
+            return []
+
+        customizations: list[Customization] = []
+        level = ConfigLevel.GLOBAL if source_level == "user" else ConfigLevel.PROJECT
+
+        # Commands: base/commands/**/*.md
+        commands_path = base / "commands"
+        customizations.extend(
+            self._discover_commands(commands_path, level, source_level)
+        )
+
+        # Agents: base/agents/*.md
+        agents_path = base / "agents"
+        customizations.extend(self._discover_agents(agents_path, level, source_level))
+
+        # Skills: base/skills/*/SKILL.md
+        skills_path = base / "skills"
+        customizations.extend(self._discover_skills(skills_path, level, source_level))
+
+        return customizations
+
+    def _discover_commands(
+        self, commands_path: Path, level: ConfigLevel, source_level: str
+    ) -> list[Customization]:
+        """Discover command customizations from commands directory."""
+        if not commands_path.exists():
+            return []
+
+        customizations: list[Customization] = []
+        parser = CommandParser(commands_path)
+
+        # Use rglob for nested commands (commands/**/*.md)
+        for md_file in commands_path.rglob("*.md"):
+            if parser.can_parse(md_file):
+                customizations.append(parser.parse(md_file, level, source_level))
+
+        return customizations
+
+    def _discover_agents(
+        self, agents_path: Path, level: ConfigLevel, source_level: str
+    ) -> list[Customization]:
+        """Discover agent customizations from agents directory."""
+        if not agents_path.exists():
+            return []
+
+        customizations: list[Customization] = []
+        parser = AgentParser(agents_path)
+
+        for md_file in agents_path.glob("*.md"):
+            if parser.can_parse(md_file):
+                customizations.append(parser.parse(md_file, level, source_level))
+
+        return customizations
+
+    def _discover_skills(
+        self, skills_path: Path, level: ConfigLevel, source_level: str
+    ) -> list[Customization]:
+        """Discover skill customizations from skills directory."""
+        if not skills_path.exists():
+            return []
+
+        customizations: list[Customization] = []
+        parser = SkillParser(skills_path, gitignore_filter=self._gitignore_filter)
+
+        for skill_dir in skills_path.iterdir():
+            if skill_dir.is_dir():
+                skill_file = skill_dir / "SKILL.md"
+                if skill_file.exists() and parser.can_parse(skill_file):
+                    customizations.append(parser.parse(skill_file, level, source_level))
+
+        return customizations
+
+    def _discover_from_plugins(self) -> list[Customization]:
+        """Discover customizations from installed Claude Code plugins."""
+        customizations: list[Customization] = []
+
+        for plugin_info in self._plugin_loader.get_all_plugins():
+            install_path = plugin_info.install_path
+            source_level = f"plugin:{plugin_info.short_name}"
+
+            # Commands
+            commands_path = install_path / "commands"
+            customizations.extend(
+                self._discover_commands(commands_path, ConfigLevel.GLOBAL, source_level)
+            )
+
+            # Agents
+            agents_path = install_path / "agents"
+            customizations.extend(
+                self._discover_agents(agents_path, ConfigLevel.GLOBAL, source_level)
+            )
+
+            # Skills
+            skills_path = install_path / "skills"
+            customizations.extend(
+                self._discover_skills(skills_path, ConfigLevel.GLOBAL, source_level)
+            )
+
+        return customizations
+
+    def refresh(self) -> None:
+        """Clear cached plugin registry to force reload."""
+        self._plugin_loader.refresh()

lazyopencode/services/claude_code/parsers/__init__.py

@@ -0,0 +1,7 @@
+"""Parsers for Claude Code customizations."""
+
+from lazyopencode.services.claude_code.parsers.agent import AgentParser
+from lazyopencode.services.claude_code.parsers.command import CommandParser
+from lazyopencode.services.claude_code.parsers.skill import SkillParser
+
+__all__ = ["CommandParser", "AgentParser", "SkillParser"]

lazyopencode/services/claude_code/parsers/agent.py

@@ -0,0 +1,58 @@
+"""Parser for Claude Code subagent customizations."""
+
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    ConfigSource,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import parse_frontmatter
+
+
+class AgentParser:
+    """Parser for subagent markdown files.
+
+    File pattern: agents/*.md
+    """
+
+    def __init__(self, agents_dir: Path) -> None:
+        """Initialize with the agents directory path."""
+        self.agents_dir = agents_dir
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a markdown file in agents directory."""
+        return path.suffix == ".md" and path.parent == self.agents_dir
+
+    def parse(self, path: Path, level: ConfigLevel, source_level: str) -> Customization:
+        """Parse a subagent markdown file."""
+        try:
+            content = path.read_text(encoding="utf-8")
+        except OSError as e:
+            return Customization(
+                name=path.stem,
+                type=CustomizationType.AGENT,
+                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", path.stem)
+        description = frontmatter.get("description")
+
+        return Customization(
+            name=name,
+            type=CustomizationType.AGENT,
+            level=level,
+            path=path,
+            description=description,
+            content=content,
+            metadata=frontmatter,
+            source=ConfigSource.CLAUDE_CODE,
+            source_level=source_level,
+        )