lazyopencode 0.1.0__py3-none-any.whl

lazyopencode/mixins/navigation.py

@@ -0,0 +1,184 @@
+"""Navigation mixin for handling panel focus and keyboard shortcuts."""
+
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from lazyopencode.app import LazyOpenCode
+    from lazyopencode.widgets.combined_panel import CombinedPanel
+    from lazyopencode.widgets.type_panel import TypePanel
+
+
+class NavigationMixin:
+    """Mixin for application navigation."""
+
+    def _get_focused_panel(self) -> "TypePanel | CombinedPanel | None":
+        """Get the currently focused panel (TypePanel or CombinedPanel)."""
+        app = cast("LazyOpenCode", self)
+        for panel in app._panels:
+            if panel.has_focus:
+                return panel
+        return None
+
+    def action_focus_next_panel(self) -> None:
+        """Focus the next panel. Ensures combined panel starts at first tab."""
+        app = cast("LazyOpenCode", self)
+        all_panels = app._panels
+
+        current_idx = -1
+        for i, panel in enumerate(all_panels):
+            if panel.has_focus:
+                current_idx = i
+                break
+
+        # If main pane is focused, current_idx stays -1, next will be 0
+        if current_idx == -1 and app._main_pane and app._main_pane.has_focus:
+            # If main pane has focus, go back to last focused panel or first
+            if app._last_focused_panel:
+                app._last_focused_panel.focus()
+                return
+            else:
+                current_idx = -1  # Will become 0
+
+        next_idx = (current_idx + 1) % len(all_panels)
+        next_panel = all_panels[next_idx]
+        if next_panel:
+            # If entering combined panel from above, start at first tab
+            from lazyopencode.widgets.combined_panel import CombinedPanel
+
+            if isinstance(next_panel, CombinedPanel):
+                next_panel.switch_to_tab(0)
+            next_panel.focus()
+
+    def action_focus_previous_panel(self) -> None:
+        """Focus the previous panel. Ensures combined panel starts at last tab."""
+        app = cast("LazyOpenCode", self)
+        all_panels = app._panels
+
+        current_idx = 0
+        for i, panel in enumerate(all_panels):
+            if panel.has_focus:
+                current_idx = i
+                break
+
+        # If main pane is focused
+        if app._main_pane and app._main_pane.has_focus:
+            # If main pane has focus, go back to last focused panel or last panel
+            if app._last_focused_panel:
+                app._last_focused_panel.focus()
+                return
+            else:
+                current_idx = 0  # Will become -1 -> last
+
+        prev_idx = (current_idx - 1) % len(all_panels)
+        prev_panel = all_panels[prev_idx]
+        if prev_panel:
+            # If entering combined panel from below (or wrap around), start at last tab
+            from lazyopencode.widgets.combined_panel import CombinedPanel
+
+            if isinstance(prev_panel, CombinedPanel):
+                prev_panel.switch_to_tab(len(prev_panel.tabs) - 1)
+            prev_panel.focus()
+
+    def action_focus_panel_1(self) -> None:
+        """Focus Commands tab in first combined 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()
+
+    def action_focus_panel_2(self) -> None:
+        """Focus Agents tab in first combined 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()
+
+    def action_focus_panel_3(self) -> None:
+        """Focus Skills panel."""
+        app = cast("LazyOpenCode", self)
+        if len(app._panels) > 1:
+            app._panels[1].focus()
+
+    def action_focus_panel_4(self) -> None:
+        """Focus Agent Memory (Rules) panel."""
+        app = cast("LazyOpenCode", self)
+        if len(app._panels) > 2:
+            app._panels[2].focus()
+
+    def action_focus_panel_5(self) -> None:
+        """Focus MCPs tab in second 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.focus()
+
+    def action_focus_panel_6(self) -> None:
+        """Focus Tools tab in second 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.focus()
+
+    def action_focus_panel_7(self) -> None:
+        """Focus Plugins tab in second 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.focus()
+
+    def action_focus_main_pane(self) -> None:
+        """Focus the main pane."""
+        app = cast("LazyOpenCode", self)
+        if app._main_pane:
+            app._main_pane.focus()
+
+    def action_prev_view(self) -> None:
+        """Switch view based on focused widget."""
+        app = cast("LazyOpenCode", self)
+        from lazyopencode.widgets.combined_panel import CombinedPanel
+
+        focused_panel = self._get_focused_panel()
+        if focused_panel and isinstance(focused_panel, CombinedPanel):
+            focused_panel.action_prev_tab()
+        elif app._main_pane:
+            app._main_pane.action_prev_view()
+
+    def action_next_view(self) -> None:
+        """Switch view based on focused widget."""
+        app = cast("LazyOpenCode", self)
+        from lazyopencode.widgets.combined_panel import CombinedPanel
+
+        focused_panel = self._get_focused_panel()
+        if focused_panel and isinstance(focused_panel, CombinedPanel):
+            focused_panel.action_next_tab()
+        elif app._main_pane:
+            app._main_pane.action_next_view()
+
+    def action_go_back_from_main_pane(self) -> None:
+        """Return focus to the panel we drilled down from."""
+        app = cast("LazyOpenCode", self)
+        if app._last_focused_panel:
+            app._last_focused_panel.focus()
+        elif app._panels:
+            # Fallback to first panel
+            app._panels[0].focus()

lazyopencode/models/__init__.py

@@ -0,0 +1,17 @@
+"""Data models for LazyOpenCode."""
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+    SkillFile,
+    SkillMetadata,
+)
+
+__all__ = [
+    "ConfigLevel",
+    "Customization",
+    "CustomizationType",
+    "SkillFile",
+    "SkillMetadata",
+]

lazyopencode/models/customization.py

@@ -0,0 +1,120 @@
+"""Core data models for LazyOpenCode."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class SkillFile:
+    """A file or directory within a skill folder."""
+
+    name: str
+    path: Path
+    content: str | None = None
+    is_directory: bool = False
+    children: list[SkillFile] = field(default_factory=list)
+
+
+@dataclass
+class SkillMetadata:
+    """Metadata specific to skills."""
+
+    files: list[SkillFile] = field(default_factory=list)
+
+
+class ConfigLevel(Enum):
+    """Configuration level for customizations."""
+
+    GLOBAL = "global"
+    PROJECT = "project"
+
+    @property
+    def label(self) -> str:
+        """Human-readable label."""
+        return self.value.capitalize()
+
+    @property
+    def icon(self) -> str:
+        """Icon for display."""
+        return "G" if self == ConfigLevel.GLOBAL else "P"
+
+
+class CustomizationType(Enum):
+    """Type of OpenCode customization."""
+
+    COMMAND = "command"
+    AGENT = "agent"
+    SKILL = "skill"
+    RULES = "rules"
+    MCP = "mcp"
+    TOOL = "tool"
+    PLUGIN = "plugin"
+
+    @property
+    def label(self) -> str:
+        """Human-readable label."""
+        return self.value.capitalize()
+
+    @property
+    def plural_label(self) -> str:
+        """Plural form for panel titles."""
+        if self == CustomizationType.RULES:
+            return "Rules"
+        return f"{self.label}s"
+
+    @property
+    def panel_key(self) -> str:
+        """Keyboard shortcut for this type's panel."""
+        mapping = {
+            CustomizationType.COMMAND: "1",
+            CustomizationType.AGENT: "2",
+            CustomizationType.SKILL: "3",
+            CustomizationType.RULES: "4",
+            CustomizationType.MCP: "5",
+            CustomizationType.TOOL: "6",
+            CustomizationType.PLUGIN: "7",
+        }
+        return mapping[self]
+
+
+@dataclass
+class Customization:
+    """Represents a single OpenCode customization."""
+
+    name: str
+    type: CustomizationType
+    level: ConfigLevel
+    path: Path
+    description: str | None = None
+    content: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+    error: str | None = None
+
+    @property
+    def type_label(self) -> str:
+        """Type label for display."""
+        return self.type.label
+
+    @property
+    def level_label(self) -> str:
+        """Level label for display."""
+        return self.level.label
+
+    @property
+    def level_icon(self) -> str:
+        """Level icon for compact display."""
+        return self.level.icon
+
+    @property
+    def display_name(self) -> str:
+        """Formatted name for display with level indicator."""
+        return f"[{self.level_icon}] {self.name}"
+
+    @property
+    def has_error(self) -> bool:
+        """Check if this customization has a parse error."""
+        return self.error is not None

lazyopencode/services/__init__.py

@@ -0,0 +1,7 @@
+"""Services for LazyOpenCode."""
+
+from lazyopencode.services.discovery import ConfigDiscoveryService
+
+__all__ = [
+    "ConfigDiscoveryService",
+]

lazyopencode/services/discovery.py

@@ -0,0 +1,350 @@
+"""Configuration discovery service."""
+
+import json
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.gitignore_filter import GitignoreFilter
+from lazyopencode.services.parsers import read_file_safe, strip_jsonc_comments
+from lazyopencode.services.parsers.agent import AgentParser
+from lazyopencode.services.parsers.command import CommandParser
+from lazyopencode.services.parsers.mcp import MCPParser
+from lazyopencode.services.parsers.plugin import PluginParser
+from lazyopencode.services.parsers.rules import RulesParser
+from lazyopencode.services.parsers.skill import SkillParser
+from lazyopencode.services.parsers.tool import ToolParser
+
+
+class ConfigDiscoveryService:
+    """Discovers OpenCode customizations from filesystem."""
+
+    def __init__(
+        self,
+        project_root: Path | None = None,
+        global_config_path: Path | None = None,
+    ) -> None:
+        """
+        Initialize discovery service.
+
+        Args:
+            project_root: Project root directory (defaults to cwd)
+            global_config_path: Global config path (defaults to ~/.config/opencode)
+        """
+        self.project_root = project_root or Path.cwd()
+        self.global_config_path = global_config_path or (
+            Path.home() / ".config" / "opencode"
+        )
+        self._gitignore_filter = GitignoreFilter(project_root=self.project_root)
+        self._parsers = {
+            CustomizationType.COMMAND: CommandParser(),
+            CustomizationType.AGENT: AgentParser(),
+            CustomizationType.SKILL: SkillParser(
+                gitignore_filter=self._gitignore_filter
+            ),
+            CustomizationType.RULES: RulesParser(),
+            CustomizationType.MCP: MCPParser(),
+            CustomizationType.TOOL: ToolParser(),
+            CustomizationType.PLUGIN: PluginParser(),
+        }
+        self._cache: list[Customization] | None = None
+
+    @property
+    def project_config_path(self) -> Path:
+        """Path to project's .opencode directory."""
+        return self.project_root / ".opencode"
+
+    def discover_all(self) -> list[Customization]:
+        """
+        Discover all customizations from global and project levels.
+
+        Returns:
+            List of all discovered customizations (de-duplicated by path)
+        """
+        if self._cache is not None:
+            return self._cache
+
+        customizations: list[Customization] = []
+
+        # Discover from global config
+        customizations.extend(self._discover_level(ConfigLevel.GLOBAL))
+
+        # Discover from project config
+        customizations.extend(self._discover_level(ConfigLevel.PROJECT))
+
+        # De-duplicate by (type, name, level, 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()))
+            if key not in seen:
+                seen.add(key)
+                unique.append(c)
+
+        self._cache = unique
+        return unique
+
+    def _discover_level(self, level: ConfigLevel) -> list[Customization]:
+        """Discover customizations at a specific level."""
+        base_path = (
+            self.global_config_path
+            if level == ConfigLevel.GLOBAL
+            else self.project_config_path
+        )
+        customizations: list[Customization] = []
+
+        # Discover commands
+        customizations.extend(self._discover_commands(base_path, level))
+        customizations.extend(self._discover_inline_commands(level))
+
+        # Discover agents
+        customizations.extend(self._discover_agents(base_path, level))
+        customizations.extend(self._discover_inline_agents(level))
+
+        # Discover skills
+        customizations.extend(self._discover_skills(base_path, level))
+
+        # Discover rules (AGENTS.md)
+        customizations.extend(self._discover_rules(level))
+
+        # Discover instruction files from opencode.json
+        customizations.extend(self._discover_instructions(level))
+
+        # Discover MCPs from opencode.json
+        customizations.extend(self._discover_mcps(level))
+
+        # Discover tools
+        customizations.extend(self._discover_tools(base_path, level))
+
+        # Discover plugins
+        customizations.extend(self._discover_plugins(base_path, level))
+
+        return customizations
+
+    def _discover_commands(
+        self, base_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover command customizations."""
+        commands_path = base_path / "command"
+        if not commands_path.exists():
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.COMMAND]
+
+        for md_file in commands_path.glob("*.md"):
+            if parser.can_parse(md_file):
+                customizations.append(parser.parse(md_file, level))
+
+        return customizations
+
+    def _discover_inline_commands(self, level: ConfigLevel) -> list[Customization]:
+        """Discover inline commands from opencode.json."""
+        if level == ConfigLevel.GLOBAL:
+            config_path = self.global_config_path / "opencode.json"
+        else:
+            config_path = self.project_root / "opencode.json"
+
+        parser = self._parsers[CustomizationType.COMMAND]
+        if isinstance(parser, CommandParser) and config_path.exists():
+            return parser.parse_inline_commands(config_path, level)
+
+        return []
+
+    def _discover_agents(
+        self, base_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover agent customizations."""
+        agents_path = base_path / "agent"
+        if not agents_path.exists():
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.AGENT]
+
+        for md_file in agents_path.glob("*.md"):
+            if parser.can_parse(md_file):
+                customizations.append(parser.parse(md_file, level))
+
+        return customizations
+
+    def _discover_inline_agents(self, level: ConfigLevel) -> list[Customization]:
+        """Discover inline agents from opencode.json."""
+        if level == ConfigLevel.GLOBAL:
+            config_path = self.global_config_path / "opencode.json"
+        else:
+            config_path = self.project_root / "opencode.json"
+
+        parser = self._parsers[CustomizationType.AGENT]
+        if isinstance(parser, AgentParser) and config_path.exists():
+            return parser.parse_inline_agents(config_path, level)
+
+        return []
+
+    def _discover_skills(
+        self, base_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover skill customizations from .opencode/skill/."""
+        customizations = []
+
+        # Discover from standard OpenCode path
+        skills_path = base_path / "skill"
+        customizations.extend(self._discover_skills_from_path(skills_path, level))
+
+        # Also discover from Claude-compatible path at project level
+        if level == ConfigLevel.PROJECT:
+            claude_skills_path = self.project_root / ".claude" / "skills"
+            customizations.extend(
+                self._discover_skills_from_path(claude_skills_path, level)
+            )
+
+        return customizations
+
+    def _discover_skills_from_path(
+        self, skills_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover skills from a specific directory path."""
+        if not skills_path.exists():
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.SKILL]
+
+        for skill_dir in skills_path.iterdir():
+            if skill_dir.is_dir():
+                skill_file = skill_dir / "SKILL.md"
+                if parser.can_parse(skill_file):
+                    customizations.append(parser.parse(skill_file, level))
+
+        return customizations
+
+    def _discover_rules(self, level: ConfigLevel) -> list[Customization]:
+        """Discover AGENTS.md rules files."""
+        customizations = []
+        parser = self._parsers[CustomizationType.RULES]
+
+        if level == ConfigLevel.GLOBAL:
+            agents_md = self.global_config_path / "AGENTS.md"
+        else:
+            agents_md = self.project_root / "AGENTS.md"
+
+        if parser.can_parse(agents_md):
+            customizations.append(parser.parse(agents_md, level))
+
+        return customizations
+
+    def _discover_mcps(self, level: ConfigLevel) -> list[Customization]:
+        """Discover MCP configurations from opencode.json."""
+        if level == ConfigLevel.GLOBAL:
+            config_path = self.global_config_path / "opencode.json"
+        else:
+            config_path = self.project_root / "opencode.json"
+
+        parser = self._parsers[CustomizationType.MCP]
+        # Cast to MCPParser to access parse_mcps
+        if isinstance(parser, MCPParser) and parser.can_parse(config_path):
+            return parser.parse_mcps(config_path, level)
+
+        return []
+
+    def _discover_tools(
+        self, base_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover tool customizations from .opencode/tool/."""
+        tools_path = base_path / "tool"
+        if not tools_path.exists():
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.TOOL]
+
+        for tool_file in tools_path.iterdir():
+            if tool_file.is_file() and parser.can_parse(tool_file):
+                customizations.append(parser.parse(tool_file, level))
+
+        return customizations
+
+    def _discover_plugins(
+        self, base_path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Discover plugin customizations from .opencode/plugin/."""
+        plugins_path = base_path / "plugin"
+        if not plugins_path.exists():
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.PLUGIN]
+
+        for plugin_file in plugins_path.iterdir():
+            if plugin_file.is_file() and parser.can_parse(plugin_file):
+                customizations.append(parser.parse(plugin_file, level))
+
+        return customizations
+
+    def _discover_instructions(self, level: ConfigLevel) -> list[Customization]:
+        """Discover instruction files from opencode.json instructions field.
+
+        Args:
+            level: Configuration level (GLOBAL or PROJECT)
+
+        Returns:
+            List of instruction file customizations
+        """
+        if level == ConfigLevel.GLOBAL:
+            config_path = self.global_config_path / "opencode.json"
+            base_dir = self.global_config_path
+        else:
+            config_path = self.project_root / "opencode.json"
+            base_dir = self.project_root
+
+        if not config_path.exists():
+            return []
+
+        # Parse opencode.json
+        content, error = read_file_safe(config_path)
+        if error or not content:
+            return []
+
+        try:
+            clean_content = strip_jsonc_comments(content)
+            config = json.loads(clean_content)
+        except (json.JSONDecodeError, Exception):
+            return []
+
+        instructions = config.get("instructions", [])
+        if not instructions:
+            return []
+
+        customizations = []
+        parser = self._parsers[CustomizationType.RULES]
+
+        for pattern in instructions:
+            # Resolve glob pattern relative to base_dir
+            matched_files = sorted(base_dir.glob(pattern))
+            for matched_file in matched_files:
+                if matched_file.is_file() and isinstance(parser, RulesParser):
+                    customizations.append(
+                        parser.parse_instruction(matched_file, base_dir, level)
+                    )
+
+        return customizations
+
+    def refresh(self) -> None:
+        """Clear cache and force re-discovery."""
+        self._cache = None
+
+    def by_type(self, ctype: CustomizationType) -> list[Customization]:
+        """Get customizations filtered by type."""
+        return [c for c in self.discover_all() if c.type == ctype]
+
+    def by_level(self, level: ConfigLevel) -> list[Customization]:
+        """Get customizations filtered by level."""
+        return [c for c in self.discover_all() if c.level == level]