lazyopencode 0.1.0__py3-none-any.whl

lazyopencode/__init__.py

@@ -0,0 +1,48 @@
+"""LazyOpenCode - TUI for managing OpenCode customizations."""
+
+try:
+    from lazyopencode._version import __version__
+except ImportError:
+    __version__ = "0.0.0+dev"
+
+import argparse
+from pathlib import Path
+
+from lazyopencode.app import create_app
+
+
+def main() -> None:
+    """Run the LazyOpenCode application."""
+    parser = argparse.ArgumentParser(
+        description="A lazygit-style TUI for visualizing OpenCode customizations",
+        prog="lazyopencode",
+    )
+
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    parser.add_argument(
+        "-d",
+        "--directory",
+        type=Path,
+        default=None,
+        help="Project directory to scan for customizations (default: current directory)",
+    )
+
+    parser.add_argument(
+        "-u",
+        "--user-config",
+        type=Path,
+        default=None,
+        help="Override user config path (default: ~/.config/opencode)",
+    )
+
+    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.run()

lazyopencode/__main__.py

@@ -0,0 +1,6 @@
+"""CLI entry point for python -m lazyopencode."""
+
+from lazyopencode import main
+
+if __name__ == "__main__":
+    main()

lazyopencode/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

lazyopencode/app.py

@@ -0,0 +1,310 @@
+"""Main LazyOpenCode TUI Application."""
+
+import os
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.containers import Container
+
+from lazyopencode import __version__
+from lazyopencode.bindings import APP_BINDINGS
+from lazyopencode.mixins.filtering import FilteringMixin
+from lazyopencode.mixins.help import HelpMixin
+from lazyopencode.mixins.navigation import NavigationMixin
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+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.detail_pane import MainPane
+from lazyopencode.widgets.filter_input import FilterInput
+from lazyopencode.widgets.status_panel import StatusPanel
+from lazyopencode.widgets.type_panel import TypePanel
+
+
+class LazyOpenCode(App, NavigationMixin, FilteringMixin, HelpMixin):
+    """A lazygit-style TUI for visualizing OpenCode customizations."""
+
+    CSS_PATH = "styles/app.tcss"
+    LAYERS = ["default", "overlay"]
+    BINDINGS = APP_BINDINGS
+
+    TITLE = f"LazyOpenCode v{__version__}"
+    SUB_TITLE = ""
+
+    def __init__(
+        self,
+        discovery_service: ConfigDiscoveryService | None = None,
+        project_root: Path | None = None,
+        global_config_path: Path | None = None,
+    ) -> None:
+        """Initialize LazyOpenCode application."""
+        super().__init__()
+        self.theme = "gruvbox"
+        self._discovery_service = discovery_service or ConfigDiscoveryService(
+            project_root=project_root,
+            global_config_path=global_config_path,
+        )
+        self._customizations: list[Customization] = []
+        self._level_filter: ConfigLevel | None = None
+        self._search_query: str = ""
+        self._panels: list[TypePanel | CombinedPanel] = []
+        self._status_panel: StatusPanel | None = None
+        self._main_pane: MainPane | None = None
+        self._filter_input: FilterInput | None = None
+        self._app_footer: AppFooter | None = None
+        self._last_focused_panel: TypePanel | CombinedPanel | None = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the application layout."""
+        with Container(id="sidebar"):
+            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
+
+            # [3] Type Panel: Skills
+            tp_skills = TypePanel(CustomizationType.SKILL, id="panel-skill")
+            tp_skills.panel_number = 3
+            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(
+                tabs=[
+                    (CustomizationType.MCP, 5, "MCPs"),
+                    (CustomizationType.TOOL, 6, "Tools"),
+                    (CustomizationType.PLUGIN, 7, "Plugins"),
+                ],
+                id="panel-combined-2",
+            )
+            self._panels.append(cp2)
+            yield cp2
+
+        self._main_pane = MainPane(id="main-pane")
+        yield self._main_pane
+
+        self._filter_input = FilterInput(id="filter-input")
+        yield self._filter_input
+
+        self._app_footer = AppFooter(id="app-footer")
+        yield self._app_footer
+
+    def on_mount(self) -> None:
+        """Handle mount event - load customizations."""
+        for theme in CUSTOM_THEMES:
+            self.register_theme(theme)
+
+        self._load_customizations()
+        self._update_status_panel()
+        project_name = self._discovery_service.project_root.name
+        self.title = f"{project_name} - LazyOpenCode"
+        # Focus first non-empty panel or first panel
+        if self._panels:
+            self._panels[0].focus()
+
+    def _update_status_panel(self) -> None:
+        """Update status panel with current config path and filter level."""
+        filter_label = self._level_filter.label if self._level_filter else "All"
+
+        if self._status_panel:
+            project_name = self._discovery_service.project_root.name
+            self._status_panel.config_path = project_name
+            self._status_panel.filter_level = filter_label
+
+        if self._app_footer:
+            self._app_footer.filter_level = filter_label
+            # Also update search active status
+            self._app_footer.search_active = bool(self._search_query)
+
+    def _load_customizations(self) -> None:
+        """Load customizations from discovery service."""
+        self._customizations = self._discovery_service.discover_all()
+        self._update_panels()
+
+    def _update_panels(self) -> None:
+        """Update all panels with filtered customizations."""
+        customizations = self._get_filtered_customizations()
+        for panel in self._panels:
+            panel.set_customizations(customizations)
+
+    def _get_filtered_customizations(self) -> list[Customization]:
+        """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]
+        if self._search_query:
+            query = self._search_query.lower()
+            result = [c for c in result if query in c.name.lower()]
+        return result
+
+    # Panel selection message handlers
+
+    def on_type_panel_selection_changed(
+        self, message: TypePanel.SelectionChanged
+    ) -> None:
+        """Handle selection change in a type panel."""
+        if self._main_pane:
+            self._main_pane.customization = message.customization
+
+    def on_type_panel_drill_down(self, message: TypePanel.DrillDown) -> None:
+        """Handle drill down into a customization."""
+        if self._main_pane:
+            self._last_focused_panel = self._get_focused_panel()
+            self._main_pane.customization = message.customization
+            self._main_pane.focus()
+
+    def on_type_panel_skill_file_selected(
+        self, message: TypePanel.SkillFileSelected
+    ) -> None:
+        """Handle skill file selection in the skills tree."""
+        if self._main_pane:
+            self._main_pane.selected_file = message.file_path
+
+    def on_combined_panel_selection_changed(
+        self, message: CombinedPanel.SelectionChanged
+    ) -> None:
+        """Handle selection change in the combined panel."""
+        if self._main_pane:
+            self._main_pane.customization = message.customization
+
+    def on_combined_panel_drill_down(self, message: CombinedPanel.DrillDown) -> None:
+        """Handle drill down from the combined panel."""
+        if self._main_pane:
+            self._last_focused_panel = self._get_focused_panel()
+            self._main_pane.customization = message.customization
+            self._main_pane.focus()
+
+    # Filter input message handlers
+
+    def on_filter_input_filter_changed(
+        self, message: FilterInput.FilterChanged
+    ) -> None:
+        """Handle filter query changes (real-time filtering)."""
+        self._search_query = message.query
+        self._last_focused_panel = None
+        if self._main_pane:
+            self._main_pane.customization = None
+        self._update_status_panel()  # Updates footer search active state
+        self._update_panels()
+
+    def on_filter_input_filter_cancelled(
+        self,
+        message: FilterInput.FilterCancelled,  # noqa: ARG002
+    ) -> None:
+        """Handle filter cancellation."""
+        self._search_query = ""
+        self._last_focused_panel = None
+        if self._main_pane:
+            self._main_pane.customization = None
+        self._update_status_panel()
+        self._update_panels()
+        # Restore focus
+        if self._panels:
+            self._panels[0].focus()
+
+    def on_filter_input_filter_applied(
+        self,
+        message: FilterInput.FilterApplied,  # noqa: ARG002
+    ) -> None:
+        """Handle filter application (Enter key)."""
+        if self._filter_input:
+            self._filter_input.hide()
+        # Restore focus
+        if self._panels:
+            self._panels[0].focus()
+
+    # Navigation actions (handled by NavigationMixin)
+
+    # Filter actions (handled by FilteringMixin)
+
+    def action_search(self) -> None:
+        """Activate search."""
+        if self._filter_input:
+            if self._filter_input.is_visible:
+                self._filter_input.hide()
+            else:
+                self._filter_input.show()
+
+    # Other actions
+
+    def action_refresh(self) -> None:
+        """Refresh customizations from disk."""
+        self._discovery_service.refresh()
+        self._load_customizations()
+        self.notify("Refreshed", severity="information")
+
+    # action_toggle_help handled by HelpMixin
+
+    def action_open_in_editor(self) -> None:
+        """Open currently selected customization in editor."""
+        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
+
+        if file_path and file_path.exists():
+            self._open_path_in_editor(file_path)
+        else:
+            self.notify("File does not exist", severity="error")
+
+    def action_open_user_config(self) -> None:
+        """Open user configuration in editor."""
+        config_path = self._discovery_service.global_config_path / "opencode.json"
+        if not config_path.exists():
+            # Fallback to the directory if file doesn't exist
+            config_path = self._discovery_service.global_config_path
+
+        self._open_path_in_editor(config_path)
+
+    def _open_path_in_editor(self, path: Path) -> None:
+        """Helper to open a path in the system editor."""
+        editor = os.environ.get("EDITOR", "vi")
+        try:
+            cmd = shlex.split(editor) + [str(path)]
+            subprocess.Popen(cmd, shell=(sys.platform == "win32"))
+        except Exception as e:
+            self.notify(f"Error opening editor: {e}", severity="error")
+
+
+def create_app(
+    project_root: Path | None = None,
+    global_config_path: Path | None = None,
+) -> LazyOpenCode:
+    """Create application with all dependencies wired."""
+    discovery_service = ConfigDiscoveryService(
+        project_root=project_root,
+        global_config_path=global_config_path,
+    )
+    return LazyOpenCode(discovery_service=discovery_service)

lazyopencode/bindings.py

@@ -0,0 +1,27 @@
+"""App keybindings configuration."""
+
+from textual.binding import Binding, BindingType
+
+APP_BINDINGS: list[BindingType] = [
+    Binding("q", "quit", "Quit"),
+    Binding("?", "toggle_help", "Help"),
+    Binding("r", "refresh", "Refresh"),
+    Binding("e", "open_in_editor", "Edit"),
+    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),
+    Binding("a", "filter_all", "All"),
+    Binding("g", "filter_global", "Global"),
+    Binding("p", "filter_project", "Project"),
+    Binding("/", "search", "Search"),
+    Binding("[", "prev_view", "[", show=True),
+    Binding("]", "next_view", "]", show=True),
+    Binding("0", "focus_main_pane", "Panel 0", show=False),
+    Binding("1", "focus_panel_1", "Panel 1", show=False),
+    Binding("2", "focus_panel_2", "Panel 2", show=False),
+    Binding("3", "focus_panel_3", "Panel 3", show=False),
+    Binding("4", "focus_panel_4", "Panel 4", show=False),
+    Binding("5", "focus_panel_5", "Panel 5", show=False),
+    Binding("6", "focus_panel_6", "Panel 6", show=False),
+    Binding("7", "focus_panel_7", "Panel 7", show=False),
+]

lazyopencode/mixins/filtering.py

@@ -0,0 +1,33 @@
+"""Filtering mixin for handling filter actions."""
+
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from lazyopencode.app import LazyOpenCode
+
+from lazyopencode.models.customization import ConfigLevel
+
+
+class FilteringMixin:
+    """Mixin for filtering actions."""
+
+    def action_filter_all(self) -> None:
+        """Show all customizations."""
+        app = cast("LazyOpenCode", self)
+        app._level_filter = None
+        app._update_status_panel()
+        app._update_panels()
+
+    def action_filter_global(self) -> None:
+        """Show only global customizations."""
+        app = cast("LazyOpenCode", self)
+        app._level_filter = ConfigLevel.GLOBAL
+        app._update_status_panel()
+        app._update_panels()
+
+    def action_filter_project(self) -> None:
+        """Show only project customizations."""
+        app = cast("LazyOpenCode", self)
+        app._level_filter = ConfigLevel.PROJECT
+        app._update_status_panel()
+        app._update_panels()

lazyopencode/mixins/help.py

@@ -0,0 +1,74 @@
+"""Help mixin for LazyOpenCode application."""
+
+from typing import TYPE_CHECKING, cast
+
+from textual.app import App
+from textual.widgets import Static
+
+from lazyopencode import __version__
+
+if TYPE_CHECKING:
+    pass
+
+
+class HelpMixin:
+    """Mixin providing help overlay functionality."""
+
+    _help_visible: bool = False
+
+    def action_toggle_help(self) -> None:
+        """Toggle help overlay visibility."""
+        if self._help_visible:
+            self._hide_help()
+        else:
+            self._show_help()
+
+    def _show_help(self) -> None:
+        """Show help overlay."""
+        app = cast("App", self)
+        help_content = f"""[bold]LazyOpenCode v{__version__}[/]
+
+[bold]Navigation[/]
+  j/k or Up/Down     Move up/down in list
+  d/u            Page down/up (detail pane)
+  g/G            Go to top/bottom
+  0              Focus main pane
+  1-3            Focus panel by number
+  4-6            Focus combined panel tab
+  Tab            Switch between panels
+  Enter          Drill down
+  Esc            Go back
+
+[bold]Filtering[/]
+  /              Search by name/description
+  a              Show all levels
+  g              Show global-level only
+  p              Show project-level only
+
+[bold]Views[/]
+  [ / ]         Main: content/metadata
+                 Combined: switch tabs
+
+[bold]Actions[/]
+  e              Open in $EDITOR
+  ctrl+u         Open User Config
+  r              Refresh from disk
+  ?              Toggle this help
+  q              Quit
+
+[dim]Press ? or Esc to close[/]"""
+
+        if not app.query("#help-overlay"):
+            help_widget = Static(help_content, id="help-overlay")
+            app.mount(help_widget)
+            self._help_visible = True
+
+    def _hide_help(self) -> None:
+        """Hide help overlay."""
+        app = cast("App", self)
+        try:
+            help_widget = app.query_one("#help-overlay")
+            help_widget.remove()
+            self._help_visible = False
+        except Exception:
+            pass