lazyopencode 0.1.0__py3-none-any.whl → 0.2.0__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.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
 __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,
 )
@@ -25,6 +26,7 @@ from lazyopencode.widgets.app_footer import AppFooter
 from lazyopencode.widgets.combined_panel import CombinedPanel
 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 +46,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 +54,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 +64,9 @@ 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._last_focused_panel: TypePanel | CombinedPanel | None = None
+        self._pending_customization: Customization | None = None
 
     def compose(self) -> ComposeResult:
         """Compose the application layout."""
@@ -68,16 +74,17 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
             self._status_panel = StatusPanel(id="status-panel")
             yield self._status_panel
 
-            # [1]+[2] Combined Panel: Commands, Agents
-            cp1 = CombinedPanel(
-                tabs=[
-                    (CustomizationType.COMMAND, 1, "Commands"),
-                    (CustomizationType.AGENT, 2, "Agents"),
-                ],
-                id="panel-combined-1",
-            )
-            self._panels.append(cp1)
-            yield cp1
+            # [1] Type Panel: Commands
+            tp_cmd = TypePanel(CustomizationType.COMMAND, id="panel-command")
+            tp_cmd.panel_number = 1
+            self._panels.append(tp_cmd)
+            yield tp_cmd
+
+            # [2] Type Panel: Agents
+            tp_agent = TypePanel(CustomizationType.AGENT, id="panel-agent")
+            tp_agent.panel_number = 2
+            self._panels.append(tp_agent)
+            yield tp_agent
 
             # [3] Type Panel: Skills
             tp_skills = TypePanel(CustomizationType.SKILL, id="panel-skill")
@@ -85,23 +92,18 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
             self._panels.append(tp_skills)
             yield tp_skills
 
-            # [4] Type Panel: Agent Memory (Rules)
-            tp_rules = TypePanel(CustomizationType.RULES, id="panel-rules")
-            tp_rules.panel_number = 4
-            self._panels.append(tp_rules)
-            yield tp_rules
-
-            # [5]+[6]+[7] Combined Panel: MCPs, Tools, Plugins
-            cp2 = CombinedPanel(
+            # [4]+[5]+[6]+[7] Combined Panel: Memory, MCPs, Tools, Plugins
+            cp = CombinedPanel(
                 tabs=[
+                    (CustomizationType.RULES, 4, "Memory"),
                     (CustomizationType.MCP, 5, "MCPs"),
                     (CustomizationType.TOOL, 6, "Tools"),
                     (CustomizationType.PLUGIN, 7, "Plugins"),
                 ],
-                id="panel-combined-2",
+                id="panel-combined",
             )
-            self._panels.append(cp2)
-            yield cp2
+            self._panels.append(cp)
+            yield cp
 
         self._main_pane = MainPane(id="main-pane")
         yield self._main_pane
@@ -109,6 +111,9 @@ 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._app_footer = AppFooter(id="app-footer")
         yield self._app_footer
 
@@ -121,6 +126,9 @@ class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
         self._update_status_panel()
         project_name = self._discovery_service.project_root.name
         self.title = f"{project_name} - LazyOpenCode"
+        self.console.set_window_title(self.title)
+        if os.name == "nt":
+            os.system(f"title {self.title}")
         # Focus first non-empty panel or first panel
         if self._panels:
             self._panels[0].focus()
@@ -154,7 +162,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()]
@@ -297,14 +310,130 @@ 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 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,8 @@ APP_BINDINGS: list[BindingType] = [
     Binding("?", "toggle_help", "Help"),
     Binding("r", "refresh", "Refresh"),
     Binding("e", "open_in_editor", "Edit"),
+    Binding("c", "copy_customization", "Copy"),
+    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/mixins/navigation.py

@@ -80,70 +80,65 @@ class NavigationMixin:
             prev_panel.focus()
 
     def action_focus_panel_1(self) -> None:
-        """Focus Commands tab in first combined panel."""
+        """Focus Commands panel."""
         app = cast("LazyOpenCode", self)
-        from lazyopencode.widgets.combined_panel import CombinedPanel
-
         if len(app._panels) > 0:
-            panel = app._panels[0]
-            if isinstance(panel, CombinedPanel):
-                panel.switch_to_tab(0)  # Commands tab
-            panel.focus()
+            app._panels[0].focus()
 
     def action_focus_panel_2(self) -> None:
-        """Focus Agents tab in first combined panel."""
+        """Focus Agents panel."""
         app = cast("LazyOpenCode", self)
-        from lazyopencode.widgets.combined_panel import CombinedPanel
-
-        if len(app._panels) > 0:
-            panel = app._panels[0]
-            if isinstance(panel, CombinedPanel):
-                panel.switch_to_tab(1)  # Agents tab
-            panel.focus()
+        if len(app._panels) > 1:
+            app._panels[1].focus()
 
     def action_focus_panel_3(self) -> None:
         """Focus Skills panel."""
         app = cast("LazyOpenCode", self)
-        if len(app._panels) > 1:
-            app._panels[1].focus()
+        if len(app._panels) > 2:
+            app._panels[2].focus()
 
     def action_focus_panel_4(self) -> None:
-        """Focus Agent Memory (Rules) panel."""
+        """Focus Agent Memory (Rules) tab in combined panel."""
         app = cast("LazyOpenCode", self)
-        if len(app._panels) > 2:
-            app._panels[2].focus()
+        from lazyopencode.widgets.combined_panel import CombinedPanel
+
+        if len(app._panels) > 3:
+            panel = app._panels[3]
+            if isinstance(panel, CombinedPanel):
+                panel.switch_to_tab(0)  # Memory tab
+            panel.focus()
 
     def action_focus_panel_5(self) -> None:
-        """Focus MCPs tab in second combined panel."""
+        """Focus MCPs tab in combined panel."""
         app = cast("LazyOpenCode", self)
         from lazyopencode.widgets.combined_panel import CombinedPanel
 
         if len(app._panels) > 3:
             panel = app._panels[3]
             if isinstance(panel, CombinedPanel):
-                panel.switch_to_tab(0)  # MCPs tab
+                panel.switch_to_tab(1)  # MCPs tab
             panel.focus()
 
     def action_focus_panel_6(self) -> None:
-        """Focus Tools tab in second combined panel."""
+        """Focus Tools tab in combined panel."""
         app = cast("LazyOpenCode", self)
         from lazyopencode.widgets.combined_panel import CombinedPanel
 
         if len(app._panels) > 3:
             panel = app._panels[3]
             if isinstance(panel, CombinedPanel):
-                panel.switch_to_tab(1)  # Tools tab
+                panel.switch_to_tab(2)  # Tools tab
             panel.focus()
 
     def action_focus_panel_7(self) -> None:
-        """Focus Plugins tab in second combined panel."""
+        """Focus Plugins tab in combined panel."""
         app = cast("LazyOpenCode", self)
         from lazyopencode.widgets.combined_panel import CombinedPanel
 
         if len(app._panels) > 3:
             panel = app._panels[3]
             if isinstance(panel, CombinedPanel):
-                panel.switch_to_tab(2)  # Plugins tab
+                panel.switch_to_tab(3)  # Plugins tab
             panel.focus()
 
     def action_focus_main_pane(self) -> None:

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,38 @@ 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]

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"]