lazyopencode 0.1.0__py3-none-any.whl

lazyopencode/services/gitignore_filter.py

@@ -0,0 +1,123 @@
+"""Gitignore-based file filtering with directory pruning for performance."""
+
+from pathlib import Path
+
+import pathspec
+
+DEFAULT_SKIP_DIRS = {
+    ".git",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    "build",
+    "dist",
+    ".eggs",
+    ".tox",
+    ".nox",
+    "htmlcov",
+    ".idea",
+    ".vscode",
+    "bin",
+    "obj",
+    ".vs",
+    "packages",
+}
+
+DEFAULT_IGNORE_PATTERNS = [
+    ".git/",
+    "node_modules/",
+    ".venv/",
+    "venv/",
+    "__pycache__/",
+    ".mypy_cache/",
+    ".pytest_cache/",
+    "build/",
+    "dist/",
+    ".eggs/",
+    "*.egg-info/",
+    ".tox/",
+    ".nox/",
+    ".coverage",
+    "htmlcov/",
+    ".idea/",
+    ".vscode/",
+    "bin/",
+    "obj/",
+    ".vs/",
+    "packages/",
+]
+
+
+class GitignoreFilter:
+    """Filter for respecting gitignore patterns during file traversal."""
+
+    def __init__(
+        self, project_root: Path | None = None, use_gitignore: bool = True
+    ) -> None:
+        """Initialize filter with optional project root for .gitignore loading."""
+        self._project_root = project_root
+        self._skip_dirs = DEFAULT_SKIP_DIRS.copy()
+        self._spec: pathspec.PathSpec | None = None
+
+        patterns = DEFAULT_IGNORE_PATTERNS.copy()
+
+        if use_gitignore and project_root:
+            gitignore_patterns = self._load_gitignore(project_root)
+            patterns.extend(gitignore_patterns)
+
+        if patterns:
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+    def _load_gitignore(self, root: Path) -> list[str]:
+        """Load and parse .gitignore file if it exists."""
+        gitignore_path = root / ".gitignore"
+        if not gitignore_path.is_file():
+            return []
+
+        try:
+            with gitignore_path.open("r", encoding="utf-8") as f:
+                return [
+                    line.strip()
+                    for line in f
+                    if line.strip() and not line.strip().startswith("#")
+                ]
+        except (OSError, UnicodeDecodeError):
+            return []
+
+    def should_skip_dir(self, dirname: str) -> bool:
+        """Fast check if directory name should be skipped."""
+        return dirname in self._skip_dirs
+
+    def is_ignored(self, path: Path) -> bool:
+        """Check if path matches gitignore patterns."""
+        if not self._spec:
+            return False
+
+        if not self._project_root:
+            rel_path = path
+        else:
+            try:
+                rel_path = path.relative_to(self._project_root)
+            except ValueError:
+                rel_path = path
+
+        return self._spec.match_file(str(rel_path))
+
+    def is_dir_ignored(self, dir_path: Path) -> bool:
+        """Check if directory path matches gitignore patterns."""
+        if not self._spec:
+            return False
+
+        if not self._project_root:
+            rel_path = dir_path
+        else:
+            try:
+                rel_path = dir_path.relative_to(self._project_root)
+            except ValueError:
+                rel_path = dir_path
+
+        dir_str = str(rel_path) + "/"
+        return self._spec.match_file(dir_str)

lazyopencode/services/parsers/__init__.py

@@ -0,0 +1,152 @@
+"""Parser utilities and interface for customization files."""
+
+import re
+from pathlib import Path
+from typing import Any, Protocol
+
+import yaml
+
+from lazyopencode.models.customization import ConfigLevel, Customization
+
+
+class ICustomizationParser(Protocol):
+    """Interface for customization parsers."""
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if this parser can handle the given path."""
+        ...
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse a file into a Customization object."""
+        ...
+
+
+def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
+    """
+    Parse YAML frontmatter from markdown content.
+
+    Frontmatter is delimited by --- at the start and end.
+
+    Args:
+        content: Full file content
+
+    Returns:
+        Tuple of (frontmatter_dict, body_content)
+    """
+    pattern = r"^---\s*\n(.*?)\n---\s*\n?(.*)$"
+    match = re.match(pattern, content, re.DOTALL)
+
+    if not match:
+        return {}, content
+
+    try:
+        frontmatter = yaml.safe_load(match.group(1)) or {}
+    except yaml.YAMLError:
+        frontmatter = {}
+
+    return frontmatter, match.group(2)
+
+
+def build_synthetic_markdown(metadata: dict[str, Any], body: str) -> str:
+    """
+    Build a synthetic markdown string with YAML frontmatter.
+
+    Args:
+        metadata: Dictionary of metadata (without the body field)
+        body: The body content
+
+    Returns:
+        Full markdown string with --- delimiters matching the pattern:
+        ^---\\s*\n(.*?)\n---\\s*\n(.*)$
+    """
+    try:
+        # Filter out empty or None values to keep it clean
+        clean_meta = {k: v for k, v in metadata.items() if v is not None}
+        if not clean_meta:
+            # Even if empty, we provide the delimiters to ensure separation in UI
+            return f"---\n---\n{body}"
+
+        frontmatter = yaml.dump(clean_meta, sort_keys=False).strip()
+        # Ensure it's not just "{}"
+        if frontmatter == "{}":
+            frontmatter = ""
+
+        # Match pattern: ^---\s*\n(.*?)\n---\s*\n(.*)$
+        # No extra newline after closing ---
+        return f"---\n{frontmatter}\n---\n{body}"
+    except Exception:
+        return body
+
+
+def strip_jsonc_comments(content: str) -> str:
+    """
+    Strip // comments from JSON content, preserving URLs.
+
+    Args:
+        content: JSON string potentially containing comments
+
+    Returns:
+        Cleaned JSON string
+    """
+    lines = []
+    for line in content.splitlines():
+        # Find // that is not part of a URL (not preceded by :)
+        pos = 0
+        while True:
+            idx = line.find("//", pos)
+            if idx == -1:
+                lines.append(line)
+                break
+            # Check if preceded by :
+            if idx > 0 and line[idx - 1] == ":":
+                pos = idx + 2
+                continue
+            # Found a comment, strip it
+            lines.append(line[:idx])
+            break
+    return "\n".join(lines)
+
+
+def read_file_safe(path: Path) -> tuple[str | None, str | None]:
+    """
+    Safely read a file, returning content or error.
+
+    Args:
+        path: Path to file
+
+    Returns:
+        Tuple of (content, error) - one will be None
+    """
+    try:
+        content = path.read_text(encoding="utf-8")
+        return content, None
+    except OSError as e:
+        return None, f"Failed to read file: {e}"
+    except UnicodeDecodeError as e:
+        return None, f"Encoding error: {e}"
+
+
+def resolve_file_references(value: str, config_dir: Path) -> str:
+    """
+    Resolve {file:./path} patterns to actual file contents.
+
+    Args:
+        value: String potentially containing {file:...} patterns
+        config_dir: Directory of the config file (for relative path resolution)
+
+    Returns:
+        String with file references replaced by contents or error indicator
+    """
+    pattern = r"\{file:([^}]+)\}"
+
+    def replace(match: re.Match) -> str:
+        file_path = match.group(1)
+        resolved = (config_dir / file_path).resolve()
+        if resolved.exists() and resolved.is_file():
+            content, error = read_file_safe(resolved)
+            if content and not error:
+                return content
+            return f"[FILE READ ERROR: {file_path}]"
+        return f"[FILE NOT FOUND: {file_path}]"
+
+    return re.sub(pattern, replace, value)

lazyopencode/services/parsers/agent.py

@@ -0,0 +1,93 @@
+"""Parser for Agent customizations."""
+
+import json
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import (
+    ICustomizationParser,
+    build_synthetic_markdown,
+    parse_frontmatter,
+    read_file_safe,
+    resolve_file_references,
+    strip_jsonc_comments,
+)
+
+
+class AgentParser(ICustomizationParser):
+    """Parses agent customizations from files or inline config."""
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is an agent markdown file."""
+        return path.is_file() and path.suffix == ".md" and path.parent.name == "agent"
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse agent file."""
+        content, error = read_file_safe(path)
+
+        metadata = {}
+        description = None
+
+        if content and not error:
+            frontmatter, _ = parse_frontmatter(content)
+            metadata = frontmatter
+            description = frontmatter.get("description")
+
+        return Customization(
+            name=path.stem,
+            type=CustomizationType.AGENT,
+            level=level,
+            path=path,
+            description=description or f"Agent: {path.stem}",
+            metadata=metadata,
+            content=content,
+            error=error,
+        )
+
+    def parse_inline_agents(
+        self, path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Parse inline agents from opencode.json."""
+        content, error = read_file_safe(path)
+        if error or not content:
+            return []
+
+        customizations = []
+        try:
+            clean_content = strip_jsonc_comments(content)
+            config = json.loads(clean_content)
+
+            agents = config.get("agent", {})
+            for agent_name, agent_config in agents.items():
+                if not isinstance(agent_config, dict):
+                    continue
+
+                metadata = agent_config.copy()
+                prompt = metadata.pop("prompt", "")
+
+                # Resolve {file:...} references in prompt
+                prompt = resolve_file_references(prompt, path.parent)
+
+                description = metadata.get("description")
+
+                markdown_content = build_synthetic_markdown(metadata, prompt)
+
+                customizations.append(
+                    Customization(
+                        name=agent_name,
+                        type=CustomizationType.AGENT,
+                        level=level,
+                        path=path,
+                        description=description or f"Agent: {agent_name}",
+                        metadata=metadata,
+                        content=markdown_content,
+                    )
+                )
+        except (json.JSONDecodeError, Exception):
+            pass
+
+        return customizations

lazyopencode/services/parsers/command.py

@@ -0,0 +1,94 @@
+"""Parser for Command customizations."""
+
+import json
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import (
+    ICustomizationParser,
+    build_synthetic_markdown,
+    parse_frontmatter,
+    read_file_safe,
+    resolve_file_references,
+    strip_jsonc_comments,
+)
+
+
+class CommandParser(ICustomizationParser):
+    """Parses command customizations from files or inline config."""
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a command markdown file."""
+        return path.is_file() and path.suffix == ".md" and path.parent.name == "command"
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse command file."""
+        content, error = read_file_safe(path)
+
+        metadata = {}
+        description = None
+
+        if content and not error:
+            frontmatter, _ = parse_frontmatter(content)
+            metadata = frontmatter
+            description = frontmatter.get("description")
+
+        return Customization(
+            name=path.stem,
+            type=CustomizationType.COMMAND,
+            level=level,
+            path=path,
+            description=description or f"Command: {path.stem}",
+            metadata=metadata,
+            content=content,
+            error=error,
+        )
+
+    def parse_inline_commands(
+        self, path: Path, level: ConfigLevel
+    ) -> list[Customization]:
+        """Parse inline commands from opencode.json."""
+        content, error = read_file_safe(path)
+        if error or not content:
+            return []
+
+        customizations = []
+        try:
+            clean_content = strip_jsonc_comments(content)
+            config = json.loads(clean_content)
+
+            commands = config.get("command", {})
+            for cmd_name, cmd_config in commands.items():
+                if not isinstance(cmd_config, dict):
+                    continue
+
+                # Create a copy to avoid mutating the original
+                metadata = cmd_config.copy()
+                template = metadata.pop("template", "")
+
+                # Resolve {file:...} references in template
+                template = resolve_file_references(template, path.parent)
+
+                description = metadata.get("description")
+
+                markdown_content = build_synthetic_markdown(metadata, template)
+
+                customizations.append(
+                    Customization(
+                        name=cmd_name,
+                        type=CustomizationType.COMMAND,
+                        level=level,
+                        path=path,
+                        description=description or f"Command: {cmd_name}",
+                        metadata=metadata,
+                        content=markdown_content,
+                    )
+                )
+        except (json.JSONDecodeError, Exception):
+            pass
+
+        return customizations

lazyopencode/services/parsers/mcp.py

@@ -0,0 +1,67 @@
+"""Parser for MCP customizations."""
+
+import json
+from pathlib import Path
+
+from lazyopencode.models.customization import (
+    ConfigLevel,
+    Customization,
+    CustomizationType,
+)
+from lazyopencode.services.parsers import (
+    ICustomizationParser,
+    read_file_safe,
+    strip_jsonc_comments,
+)
+
+
+class MCPParser(ICustomizationParser):
+    """Parses MCP configurations from opencode.json."""
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is opencode.json file."""
+        return path.is_file() and path.name == "opencode.json"
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """
+        Parse MCP file.
+        Note: This returns a 'container' customization for the file itself.
+        Real logic for individual MCPs is in parse_mcps.
+        """
+        return Customization(
+            name="opencode.json",
+            type=CustomizationType.MCP,
+            level=level,
+            path=path,
+            description="MCP Configuration File",
+        )
+
+    def parse_mcps(self, path: Path, level: ConfigLevel) -> list[Customization]:
+        """Parse opencode.json and return list of MCP customizations."""
+        content, error = read_file_safe(path)
+        if error or not content:
+            return []
+
+        customizations = []
+        try:
+            clean_content = strip_jsonc_comments(content)
+            config = json.loads(clean_content)
+
+            mcps = config.get("mcp", {})
+            for mcp_name, mcp_config in mcps.items():
+                mcp_type = mcp_config.get("type", "unknown")
+                customizations.append(
+                    Customization(
+                        name=mcp_name,
+                        type=CustomizationType.MCP,
+                        level=level,
+                        path=path,
+                        description=f"MCP ({mcp_type})",
+                        metadata=mcp_config,
+                        content=json.dumps(mcp_config, indent=2),
+                    )
+                )
+        except (json.JSONDecodeError, Exception):
+            pass
+
+        return customizations

lazyopencode/services/parsers/plugin.py

@@ -0,0 +1,127 @@
+"""Parser for Plugin 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 PluginParser(ICustomizationParser):
+    """Parses plugin customizations from TypeScript/JavaScript files.
+
+    Plugins are JS/TS modules that export plugin functions. Each function
+    receives a context object and returns a hooks object to extend OpenCode.
+
+    Paths:
+        - Global: ~/.config/opencode/plugin/*.ts or *.js
+        - Project: .opencode/plugin/*.ts or *.js
+    """
+
+    VALID_EXTENSIONS = {".ts", ".js"}
+
+    def can_parse(self, path: Path) -> bool:
+        """Check if path is a plugin file."""
+        return (
+            path.is_file()
+            and path.suffix in self.VALID_EXTENSIONS
+            and path.parent.name == "plugin"
+        )
+
+    def parse(self, path: Path, level: ConfigLevel) -> Customization:
+        """Parse plugin file - shows source code as preview."""
+        content, error = read_file_safe(path)
+
+        description = None
+        exports: list[str] = []
+        hooks: list[str] = []
+
+        if content and not error:
+            exports = self._extract_exports(content)
+            hooks = self._extract_hooks(content)
+            description = self._build_description(exports, hooks)
+
+        return Customization(
+            name=path.stem,
+            type=CustomizationType.PLUGIN,
+            level=level,
+            path=path,
+            description=description or f"Plugin: {path.stem}",
+            content=content,
+            metadata={
+                "exports": exports,
+                "hooks": hooks,
+            },
+            error=error,
+        )
+
+    def _extract_exports(self, content: str) -> list[str]:
+        """
+        Extract exported plugin names from the file.
+
+        Looks for patterns like:
+        - export const MyPlugin = ...
+        - export function MyPlugin ...
+        - export { MyPlugin }
+        """
+        exports: list[str] = []
+
+        # Match: export const/let/var Name =
+        const_pattern = r"export\s+(?:const|let|var)\s+(\w+)\s*[=:]"
+        exports.extend(re.findall(const_pattern, content))
+
+        # Match: export function Name
+        func_pattern = r"export\s+function\s+(\w+)"
+        exports.extend(re.findall(func_pattern, content))
+
+        # Match: export { Name, Name2 }
+        named_pattern = r"export\s*\{\s*([^}]+)\s*\}"
+        for match in re.findall(named_pattern, content):
+            names = [n.strip().split(" as ")[0].strip() for n in match.split(",")]
+            exports.extend(n for n in names if n)
+
+        return list(set(exports))
+
+    def _extract_hooks(self, content: str) -> list[str]:
+        """
+        Extract hook names that the plugin subscribes to.
+
+        Looks for patterns like:
+        - "session.idle": async (...)
+        - 'tool.execute.before': (...)
+        - event: async ({ event }) => { ... }
+        """
+        hooks: list[str] = []
+
+        # Match quoted hook names like "session.idle" or 'tool.execute.before'
+        quoted_pattern = r'["\']([a-z]+(?:\.[a-z]+)+)["\']:\s*(?:async\s*)?\('
+        hooks.extend(re.findall(quoted_pattern, content))
+
+        # Match 'event' handler
+        if re.search(r"\bevent\s*:\s*(?:async\s*)?\(", content):
+            hooks.append("event")
+
+        # Match 'tool' object for custom tools
+        if re.search(r"\btool\s*:\s*\{", content):
+            hooks.append("tool (custom tools)")
+
+        return list(set(hooks))
+
+    def _build_description(self, exports: list[str], hooks: list[str]) -> str | None:
+        """Build a description from extracted info."""
+        parts: list[str] = []
+
+        if exports:
+            parts.append(f"Exports: {', '.join(sorted(exports))}")
+
+        if hooks:
+            parts.append(f"Hooks: {', '.join(sorted(hooks))}")
+
+        return " | ".join(parts) if parts else None