lazyopencode 0.1.0__py3-none-any.whl

lazyopencode/services/parsers/rules.py

@@ -0,0 +1,65 @@
+"""Parser for Rules customizations."""
+
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import ICustomizationParser, read_file_safe
+
+
+class RulesParser(ICustomizationParser):
+    """Parses AGENTS.md files and instruction files."""
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is an AGENTS.md file."""
+        return path.is_file() and path.name == "AGENTS.md"
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse rules file."""
+        content, error = read_file_safe(path)
+
+        return Customization(
+            name="AGENTS.md",
+            type=CustomizationType.RULES,
+            level=level,
+            path=path,
+            description="Project rules and instructions",
+            content=content,
+            error=error,
+        )
+
+    def parse_instruction(
+        self, path: Path, base_dir: Path, level: ConfigLevel
+    ) -> Customization:
+        """Parse an instruction file referenced from opencode.json instructions field.
+
+        Args:
+            path: Path to the instruction file
+            base_dir: Base directory for computing relative path
+            level: Configuration level (GLOBAL or PROJECT)
+
+        Returns:
+            Customization object for the instruction file
+        """
+        content, error = read_file_safe(path)
+
+        # Compute relative path for display name
+        try:
+            # Use forward slashes for consistency across platforms
+            relative_name = str(path.relative_to(base_dir)).replace("\\", "/")
+        except ValueError:
+            # If path is not relative to base_dir, use the filename
+            relative_name = path.name
+
+        return Customization(
+            name=relative_name,
+            type=CustomizationType.RULES,
+            level=level,
+            path=path,
+            description="Instruction file",
+            content=content,
+            error=error,
+        )

lazyopencode/services/parsers/skill.py

@@ -0,0 +1,138 @@
+"""Parser for Skill customizations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+    SkillFile,
+    SkillMetadata,
+)
+from lazyopencode.services.parsers import (
+    ICustomizationParser,
+    parse_frontmatter,
+    read_file_safe,
+)
+
+if TYPE_CHECKING:
+    from lazyopencode.services.gitignore_filter import GitignoreFilter
+
+
+def _read_skill_files(
+    directory: Path,
+    exclude: set[str] | None = None,
+    gitignore_filter: GitignoreFilter | None = None,
+) -> list[SkillFile]:
+    """Recursively read all files in a skill directory."""
+    if exclude is None:
+        exclude = set()
+
+    files: list[SkillFile] = []
+    try:
+        # Sort entries: directories first, then alphabetically
+        entries = sorted(
+            directory.iterdir(), key=lambda p: (p.is_file(), p.name.lower())
+        )
+    except OSError:
+        return files
+
+    for entry in entries:
+        # Skip excluded files and hidden files
+        if entry.name in exclude or entry.name.startswith("."):
+            continue
+
+        if entry.is_dir():
+            # Skip gitignored directories
+            if gitignore_filter and (
+                gitignore_filter.should_skip_dir(entry.name)
+                or gitignore_filter.is_dir_ignored(entry)
+            ):
+                continue
+
+            children = _read_skill_files(entry, exclude, gitignore_filter)
+            files.append(
+                SkillFile(
+                    name=entry.name,
+                    path=entry,
+                    is_directory=True,
+                    children=children,
+                )
+            )
+        elif entry.is_file():
+            try:
+                content = entry.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                content = None
+            files.append(
+                SkillFile(
+                    name=entry.name,
+                    path=entry,
+                    content=content,
+                )
+            )
+
+    return files
+
+
+class SkillParser(ICustomizationParser):
+    """Parses skill/*/SKILL.md files."""
+
+    def __init__(
+        self,
+        skills_dir: Path | None = None,
+        gitignore_filter: GitignoreFilter | None = None,
+    ) -> None:
+        """Initialize with optional skills directory and gitignore filter."""
+        self._skills_dir = skills_dir
+        self._filter = gitignore_filter
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a SKILL.md file in a skill directory."""
+        return (
+            path.is_file()
+            and path.name == "SKILL.md"
+            and path.parent.parent.name == "skill"
+        )
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse skill file and detect directory contents."""
+        skill_dir = path.parent
+        content, error = read_file_safe(path)
+
+        if error:
+            return Customization(
+                name=skill_dir.name,
+                type=CustomizationType.SKILL,
+                level=level,
+                path=path,
+                error=error,
+            )
+
+        frontmatter, _ = parse_frontmatter(content or "")
+
+        # Extract name from frontmatter or fallback to directory name
+        name = frontmatter.get("name", skill_dir.name)
+        description = frontmatter.get("description")
+
+        # Recursively read all files in the skill directory
+        skill_files = _read_skill_files(
+            skill_dir, exclude={"SKILL.md"}, gitignore_filter=self._filter
+        )
+
+        # Build metadata with file tree
+        metadata = SkillMetadata(files=skill_files)
+
+        return Customization(
+            name=name,
+            type=CustomizationType.SKILL,
+            level=level,
+            path=path,
+            description=description or f"Skill: {skill_dir.name}",
+            metadata=metadata.__dict__,
+            content=content,
+            error=error,
+        )

lazyopencode/services/parsers/tool.py

@@ -0,0 +1,67 @@
+"""Parser for Tool customizations."""
+
+import re
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import (
+    ICustomizationParser,
+    read_file_safe,
+)
+
+
+class ToolParser(ICustomizationParser):
+    """Parses tool customizations from TypeScript/JavaScript files."""
+
+    VALID_EXTENSIONS = {".ts", ".js"}
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a tool file."""
+        return (
+            path.is_file()
+            and path.suffix in self.VALID_EXTENSIONS
+            and path.parent.name == "tool"
+        )
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse tool file - shows source code as preview."""
+        content, error = read_file_safe(path)
+
+        description = None
+        if content and not error:
+            description = self._extract_description(content)
+
+        return Customization(
+            name=path.stem,
+            type=CustomizationType.TOOL,
+            level=level,
+            path=path,
+            description=description or f"Tool: {path.stem}",
+            content=content,
+            error=error,
+        )
+
+    def _extract_description(self, content: str) -> str | None:
+        """
+        Extract description from tool definition.
+
+        Looks for patterns like:
+        - description: "...",
+        - description: '...',
+        - description: `...`,
+        """
+        patterns = [
+            r'description:\s*["\']([^"\']+)["\']',
+            r"description:\s*`([^`]+)`",
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, content)
+            if match:
+                return match.group(1).strip()
+
+        return None

lazyopencode/styles/app.tcss

@@ -0,0 +1,173 @@
+/* LazyOpenCode TUI Application Styles */
+/* Lazygit-inspired panel layout */
+
+Screen {
+    layout: grid;
+    grid-size: 2;
+    grid-columns: 1fr 2fr;
+    background: $surface;
+}
+
+#sidebar {
+    layout: vertical;
+    height: 100%;
+}
+
+#main-pane {
+    height: 100%;
+}
+
+/* Status Panel */
+StatusPanel {
+    height: 3;
+    border: solid $primary;
+    padding: 0 1;
+    margin-bottom: 0;
+    border-title-align: left;
+}
+
+/* Type Panels */
+TypePanel {
+    height: 1fr;
+    min-height: 3;
+    border: solid $primary;
+    padding: 0 1;
+    margin-bottom: 0;
+    border-title-align: left;
+    border-subtitle-align: right;
+}
+
+TypePanel:focus {
+    border: double $accent;
+}
+
+TypePanel:focus-within {
+    border: double $accent;
+}
+
+TypePanel.empty {
+    height: 3;
+    min-height: 3;
+    max-height: 3;
+}
+
+TypePanel .items-container {
+    height: 1fr;
+    scrollbar-gutter: stable;
+}
+
+TypePanel .item {
+    height: 1;
+    width: 100%;
+    text-wrap: nowrap;
+    text-overflow: ellipsis;
+}
+
+TypePanel .item-selected {
+    background: $accent;
+    text-style: bold;
+}
+
+/* Combined Panel (Rules, MCPs, Plugins) */
+CombinedPanel {
+    height: 1fr;
+    min-height: 3;
+    border: solid $primary;
+    padding: 0 1;
+    margin-bottom: 0;
+    border-title-align: left;
+    border-subtitle-align: right;
+}
+
+CombinedPanel:focus {
+    border: double $accent;
+}
+
+CombinedPanel:focus-within {
+    border: double $accent;
+}
+
+CombinedPanel.empty {
+    height: 3;
+    min-height: 3;
+    max-height: 3;
+}
+
+CombinedPanel .items-container {
+    height: 1fr;
+    scrollbar-gutter: stable;
+}
+
+CombinedPanel .item {
+    height: 1;
+    width: 100%;
+    text-wrap: nowrap;
+    text-overflow: ellipsis;
+}
+
+CombinedPanel .item-selected {
+    background: $accent;
+    text-style: bold;
+}
+
+/* Main Pane */
+MainPane {
+    height: 100%;
+    border: solid $primary;
+    padding: 1 0 1 2;
+    overflow-y: auto;
+    border-title-align: left;
+}
+
+MainPane:focus {
+    border: double $accent;
+}
+
+MainPane .pane-content {
+    width: 100%;
+}
+
+/* Footer */
+AppFooter {
+    dock: bottom;
+    height: 1;
+    background: $panel;
+}
+
+/* Filter Input */
+FilterInput {
+    dock: bottom;
+    height: 3;
+    border: solid $accent;
+    padding: 0 1;
+    display: none;
+}
+
+FilterInput.visible {
+    display: block;
+    margin-bottom: 1;
+}
+
+FilterInput:focus-within {
+    border: double $accent;
+}
+
+FilterInput Input {
+    width: 100%;
+    height: 1;
+    border: none;
+    padding: 0;
+    background: transparent;
+}
+
+/* Help Overlay */
+#help-overlay {
+    layer: overlay;
+    dock: right;
+    width: 60;
+    height: 100%;
+    border: double $accent;
+    background: $surface;
+    padding: 1 2;
+    overflow-y: auto;
+}

lazyopencode/themes.py

@@ -0,0 +1,30 @@
+"""Custom themes for LazyOpenCode TUI application."""
+
+from textual.theme import Theme
+
+LAZYGIT_THEME = Theme(
+    name="lazygit",
+    primary="#d4d4d4",
+    secondary="#808080",
+    accent="#4a90d9",
+    foreground="#cccccc",
+    background="#1a1a1a",
+    surface="#222222",
+    panel="#2d2d2d",
+    success="#98c379",
+    warning="#e5c07b",
+    error="#e06c75",
+    dark=True,
+    variables={
+        "border": "#3a3a3a",
+        "footer-background": "#1a1a1a",
+        "footer-foreground": "#808080",
+        "footer-key-background": "#1a1a1a",
+        "footer-key-foreground": "#4a90d9",
+        "footer-description-foreground": "#707070",
+    },
+)
+
+CUSTOM_THEMES = [LAZYGIT_THEME]
+
+DEFAULT_THEME = "gruvbox"

lazyopencode/widgets/__init__.py

@@ -0,0 +1,17 @@
+"""Widgets for LazyOpenCode."""
+
+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
+
+__all__ = [
+    "StatusPanel",
+    "TypePanel",
+    "CombinedPanel",
+    "MainPane",
+    "AppFooter",
+    "FilterInput",
+]

lazyopencode/widgets/app_footer.py

@@ -0,0 +1,71 @@
+"""AppFooter widget for displaying keybindings."""
+
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+from lazyopencode.widgets.helpers.rendering import format_keybinding
+
+
+class AppFooter(Widget):
+    """Footer displaying available keybindings."""
+
+    DEFAULT_CSS = """
+    AppFooter {
+        dock: bottom;
+        height: 1;
+        background: $panel;
+    }
+
+    AppFooter .footer-content {
+        width: 100%;
+        text-align: center;
+    }
+    """
+
+    filter_level: reactive[str] = reactive("All")
+    search_active: reactive[bool] = reactive(False)
+
+    def compose(self) -> ComposeResult:
+        """Compose the footer content."""
+        yield Static(self._get_footer_text(), classes="footer-content")
+
+    def _get_footer_text(self) -> str:
+        """Build the footer text with keybindings."""
+        all_key = format_keybinding("a", "All", active=self.filter_level == "All")
+        user_key = format_keybinding(
+            "g", "Global", active=self.filter_level == "Global"
+        )
+        project_key = format_keybinding(
+            "p", "Project", active=self.filter_level == "Project"
+        )
+        search_key = format_keybinding("/", "Search", active=self.search_active)
+
+        return (
+            f"[bold]q[/] Quit  [bold]?[/] Help  [bold]r[/] Refresh  "
+            f"[bold]e[/] Edit  "
+            f"{all_key}  {user_key}  {project_key}  "
+            f"{search_key}  │  [bold][$accent]^p[/][/] Palette"
+        )
+
+    def on_mount(self) -> None:
+        """Handle mount event."""
+        pass
+
+    def _update_content(self) -> None:
+        """Update the footer content."""
+        if self.is_mounted:
+            try:
+                content = self.query_one(".footer-content", Static)
+                content.update(self._get_footer_text())
+            except Exception:
+                pass
+
+    def watch_filter_level(self, _level: str) -> None:
+        """React to filter level changes."""
+        self._update_content()
+
+    def watch_search_active(self, _active: bool) -> None:
+        """React to search active changes."""
+        self._update_content()