llm-ide-rules 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

llm_ide_rules/agents/opencode.py

@@ -0,0 +1,130 @@
+"""OpenCode agent implementation."""
+
+from pathlib import Path
+
+from llm_ide_rules.agents.base import (
+    BaseAgent,
+    get_ordered_files,
+    resolve_header_from_stem,
+    trim_content,
+)
+from llm_ide_rules.mcp import McpServer
+
+
+class OpenCodeAgent(BaseAgent):
+    """Agent for OpenCode."""
+
+    name = "opencode"
+    rules_dir = None
+    commands_dir = ".opencode/commands"
+    rule_extension = None
+    command_extension = ".md"
+
+    mcp_global_path = ".config/opencode/opencode.json"
+    mcp_project_path = "opencode.json"
+    mcp_root_key = "mcp"
+
+    def bundle_rules(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """OpenCode doesn't support rules."""
+        return False
+
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """Bundle OpenCode command files (.md) into a single output file."""
+        commands_dir = self.commands_dir
+        if not commands_dir:
+            return False
+
+        commands_path = output_file.parent / commands_dir
+        if not commands_path.exists():
+            return False
+
+        extension = self.command_extension
+        if not extension:
+            return False
+
+        command_files = list(commands_path.glob(f"*{extension}"))
+        if not command_files:
+            return False
+
+        ordered_commands = get_ordered_files(
+            command_files, list(section_globs.keys()) if section_globs else None
+        )
+
+        content_parts: list[str] = []
+        for command_file in ordered_commands:
+            content = command_file.read_text().strip()
+            if not content:
+                continue
+
+            header = resolve_header_from_stem(
+                command_file.stem, section_globs if section_globs else {}
+            )
+            content_parts.append(f"## {header}\n\n")
+            content_parts.append(content)
+            content_parts.append("\n\n")
+
+        if not content_parts:
+            return False
+
+        output_file.write_text("".join(content_parts))
+        return True
+
+    def write_rule(
+        self,
+        content_lines: list[str],
+        filename: str,
+        rules_dir: Path,
+        glob_pattern: str | None = None,
+    ) -> None:
+        """OpenCode doesn't support rules."""
+        pass
+
+    def write_command(
+        self,
+        content_lines: list[str],
+        filename: str,
+        commands_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """Write an OpenCode command file (.md) - plain markdown, no frontmatter."""
+        extension = self.command_extension or ".md"
+        filepath = commands_dir / f"{filename}{extension}"
+
+        trimmed = trim_content(content_lines)
+        filepath.write_text("".join(trimmed))
+
+    def transform_mcp_server(self, server: McpServer) -> dict:
+        """Transform unified server to OpenCode format (merged command array, environment key)."""
+        if server.url:
+            result = {"type": "sse", "url": server.url, "enabled": True}
+            if server.env:
+                result["environment"] = server.env
+            return result
+
+        result = {
+            "type": "local",
+            "command": [server.command] + (server.args or []),
+            "enabled": True,
+        }
+        if server.env:
+            result["environment"] = server.env
+        return result
+
+    def reverse_transform_mcp_server(self, name: str, config: dict) -> McpServer:
+        """Transform OpenCode config back to unified format."""
+        if config.get("type") == "sse":
+            return McpServer(
+                url=config["url"],
+                env=config.get("environment"),
+            )
+
+        command_array = config["command"]
+        return McpServer(
+            command=command_array[0] if command_array else None,
+            args=command_array[1:] if len(command_array) > 1 else [],
+            env=config.get("environment"),
+        )

llm_ide_rules/commands/delete.py

@@ -1,24 +1,20 @@
 """Delete command: Remove downloaded LLM instruction files."""
 
-import logging
 import shutil
 from pathlib import Path
-from typing import List
 
-import structlog
 import typer
 from typing_extensions import Annotated
 
 from llm_ide_rules.commands.download import INSTRUCTION_TYPES, DEFAULT_TYPES
-
-logger = structlog.get_logger()
+from llm_ide_rules.log import log
 
 
 def find_files_to_delete(
-    instruction_types: List[str], target_dir: Path
-) -> tuple[List[Path], List[Path]]:
+    instruction_types: list[str], target_dir: Path
+) -> tuple[list[Path], list[Path]]:
     """Find all files and directories that would be deleted.
-    
+
     Returns:
         Tuple of (directories, files) to delete
     """
@@ -27,7 +23,7 @@ def find_files_to_delete(
 
     for inst_type in instruction_types:
         if inst_type not in INSTRUCTION_TYPES:
-            logger.warning("Unknown instruction type", type=inst_type)
+            log.warning("unknown instruction type", type=inst_type)
             continue
 
         config = INSTRUCTION_TYPES[inst_type]
@@ -51,7 +47,7 @@ def find_files_to_delete(
 
 def delete_main(
     instruction_types: Annotated[
-        List[str],
+        list[str] | None,
         typer.Argument(
             help="Types of instructions to delete (cursor, github, gemini, claude, agent, agents). Deletes everything by default."
         ),
@@ -61,10 +57,9 @@ def delete_main(
     ] = ".",
     yes: Annotated[
         bool,
-        typer.Option("--yes", "-y", help="Skip confirmation prompt and delete immediately"),
-    ] = False,
-    verbose: Annotated[
-        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
+        typer.Option(
+            "--yes", "-y", help="Skip confirmation prompt and delete immediately"
+        ),
     ] = False,
 ):
     """Remove downloaded LLM instruction files.
@@ -90,19 +85,13 @@ def delete_main(
     # Delete from a specific directory
     llm_ide_rules delete --target ./my-project
     """
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
-
     if not instruction_types:
         instruction_types = DEFAULT_TYPES
 
     invalid_types = [t for t in instruction_types if t not in INSTRUCTION_TYPES]
     if invalid_types:
-        logger.error(
-            "Invalid instruction types",
+        log.error(
+            "invalid instruction types",
             invalid_types=invalid_types,
             valid_types=list(INSTRUCTION_TYPES.keys()),
         )
@@ -111,12 +100,13 @@ def delete_main(
     target_path = Path(target_dir).resolve()
 
     if not target_path.exists():
-        logger.error("Target directory does not exist", target_dir=str(target_path))
-        typer.echo(f"Error: Target directory does not exist: {target_path}")
+        log.error("target directory does not exist", target_dir=str(target_path))
+        error_msg = f"Target directory does not exist: {target_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         raise typer.Exit(1)
 
-    logger.info(
-        "Finding files to delete",
+    log.info(
+        "finding files to delete",
         instruction_types=instruction_types,
         target_dir=str(target_path),
     )
@@ -126,7 +116,7 @@ def delete_main(
     )
 
     if not dirs_to_delete and not files_to_delete:
-        logger.info("No files found to delete")
+        log.info("no files found to delete")
         typer.echo("No matching instruction files found to delete.")
         return
 
@@ -151,7 +141,7 @@ def delete_main(
         typer.echo()
         confirm = typer.confirm("Are you sure you want to delete these files?")
         if not confirm:
-            logger.info("Deletion cancelled by user")
+            log.info("deletion cancelled by user")
             typer.echo("Deletion cancelled.")
             raise typer.Exit(0)
 
@@ -159,21 +149,21 @@ def delete_main(
 
     for dir_path in dirs_to_delete:
         try:
-            logger.info("Deleting directory", path=str(dir_path))
+            log.info("deleting directory", path=str(dir_path))
             shutil.rmtree(dir_path)
             deleted_count += 1
         except Exception as e:
-            logger.error("Failed to delete directory", path=str(dir_path), error=str(e))
+            log.error("failed to delete directory", path=str(dir_path), error=str(e))
             typer.echo(f"Error deleting {dir_path}: {e}", err=True)
 
     for file_path in files_to_delete:
         try:
-            logger.info("Deleting file", path=str(file_path))
+            log.info("deleting file", path=str(file_path))
             file_path.unlink()
             deleted_count += 1
         except Exception as e:
-            logger.error("Failed to delete file", path=str(file_path), error=str(e))
+            log.error("failed to delete file", path=str(file_path), error=str(e))
             typer.echo(f"Error deleting {file_path}: {e}", err=True)
 
-    logger.info("Deletion completed", deleted_count=deleted_count, total_items=total_items)
-    typer.echo(f"\nSuccessfully deleted {deleted_count} of {total_items} items.")
+    success_msg = f"Successfully deleted {deleted_count} of {total_items} items."
+    typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))

llm_ide_rules/commands/download.py

@@ -1,18 +1,17 @@
 """Download command: Download LLM instruction files from GitHub repositories."""
 
-import logging
 import re
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import List
 
 import requests
-import structlog
 import typer
 from typing_extensions import Annotated
 
-logger = structlog.get_logger()
+from llm_ide_rules.commands.explode import explode_implementation
+from llm_ide_rules.constants import VALID_AGENTS
+from llm_ide_rules.log import log
 
 DEFAULT_REPO = "iloveitaly/llm-ide-rules"
 DEFAULT_BRANCH = "master"
@@ -20,7 +19,7 @@ DEFAULT_BRANCH = "master"
 
 def normalize_repo(repo: str) -> str:
     """Normalize repository input to user/repo format.
-    
+
     Handles both formats:
     - user/repo (unchanged)
     - https://github.com/user/repo/ (extracts user/repo)
@@ -28,27 +27,49 @@ def normalize_repo(repo: str) -> str:
     # If it's already in user/repo format, return as-is
     if "/" in repo and not repo.startswith("http"):
         return repo
-    
+
     # Extract user/repo from GitHub URL
     github_pattern = r"https?://github\.com/([^/]+/[^/]+)/?.*"
     match = re.match(github_pattern, repo)
-    
+
     if match:
         return match.group(1)
-    
+
     # If no pattern matches, assume it's already in the correct format
     return repo
 
+
 # Define what files/directories each instruction type includes
+# For agents supported by 'explode' (cursor, github, gemini, claude, opencode),
+# we don't download specific directories anymore. Instead, we download the source
+# files (instructions.md, commands.md) and generate them locally using explode.
+# The directories listed here are what gets created by explode and what delete removes.
 INSTRUCTION_TYPES = {
-    "cursor": {"directories": [".cursor"], "files": []},
+    "cursor": {
+        "directories": [".cursor"],
+        "files": [],
+        "include_patterns": [],
+    },
     "github": {
-        "directories": [".github"],
+        "directories": [".github/instructions", ".github/prompts"],
+        "files": [".github/copilot-instructions.md"],
+        "include_patterns": [],
+    },
+    "gemini": {
+        "directories": [".gemini"],
+        "files": ["GEMINI.md"],
+        "include_patterns": [],
+    },
+    "claude": {
+        "directories": [".claude"],
+        "files": ["CLAUDE.md"],
+        "include_patterns": [],
+    },
+    "opencode": {
+        "directories": [".opencode"],
         "files": [],
-        "exclude_patterns": ["workflows/*"],
+        "include_patterns": [],
     },
-    "gemini": {"directories": [], "files": ["GEMINI.md"]},
-    "claude": {"directories": [], "files": ["CLAUDE.md"]},
     "agent": {"directories": [], "files": ["AGENT.md"]},
     "agents": {"directories": [], "files": [], "recursive_files": ["AGENTS.md"]},
 }
@@ -62,13 +83,19 @@ def download_and_extract_repo(repo: str, branch: str = DEFAULT_BRANCH) -> Path:
     normalized_repo = normalize_repo(repo)
     zip_url = f"https://github.com/{normalized_repo}/archive/{branch}.zip"
 
-    logger.info("Downloading repository", repo=repo, normalized_repo=normalized_repo, branch=branch, url=zip_url)
+    log.info(
+        "downloading repository",
+        repo=repo,
+        normalized_repo=normalized_repo,
+        branch=branch,
+        url=zip_url,
+    )
 
     try:
         response = requests.get(zip_url, timeout=30)
         response.raise_for_status()
     except requests.RequestException as e:
-        logger.error("Failed to download repository", error=str(e), url=zip_url)
+        log.error("failed to download repository", error=str(e), url=zip_url)
         raise typer.Exit(1)
 
     # Create temporary directory and file
@@ -88,24 +115,24 @@ def download_and_extract_repo(repo: str, branch: str = DEFAULT_BRANCH) -> Path:
     # Find the extracted repository directory (should be the only directory)
     repo_dirs = [d for d in extract_dir.iterdir() if d.is_dir()]
     if not repo_dirs:
-        logger.error("No directories found in extracted ZIP")
+        log.error("no directories found in extracted zip")
         raise typer.Exit(1)
 
     repo_dir = repo_dirs[0]
-    logger.info("Repository extracted", path=str(repo_dir))
+    log.info("repository extracted", path=str(repo_dir))
 
     return repo_dir
 
 
 def copy_instruction_files(
-    repo_dir: Path, instruction_types: List[str], target_dir: Path
+    repo_dir: Path, instruction_types: list[str], target_dir: Path
 ):
     """Copy instruction files from the repository to the target directory."""
     copied_items = []
 
     for inst_type in instruction_types:
         if inst_type not in INSTRUCTION_TYPES:
-            logger.warning("Unknown instruction type", type=inst_type)
+            log.warning("unknown instruction type", type=inst_type)
             continue
 
         config = INSTRUCTION_TYPES[inst_type]
@@ -116,8 +143,8 @@ def copy_instruction_files(
             target_subdir = target_dir / dir_name
 
             if source_dir.exists():
-                logger.info(
-                    "Copying directory",
+                log.info(
+                    "copying directory",
                     source=str(source_dir),
                     target=str(target_subdir),
                 )
@@ -127,7 +154,10 @@ def copy_instruction_files(
 
                 # Copy all files from source to target
                 copy_directory_contents(
-                    source_dir, target_subdir, config.get("exclude_patterns", [])
+                    source_dir,
+                    target_subdir,
+                    config.get("exclude_patterns", []),
+                    config.get("include_patterns", []),
                 )
                 copied_items.append(f"{dir_name}/")
 
@@ -137,8 +167,8 @@ def copy_instruction_files(
             target_file = target_dir / file_name
 
             if source_file.exists():
-                logger.info(
-                    "Copying file", source=str(source_file), target=str(target_file)
+                log.info(
+                    "copying file", source=str(source_file), target=str(target_file)
                 )
 
                 # Create parent directories if needed
@@ -158,55 +188,56 @@ def copy_instruction_files(
 
 def copy_recursive_files(
     repo_dir: Path, target_dir: Path, file_pattern: str
-) -> List[str]:
+) -> list[str]:
     """Recursively copy files matching pattern, preserving directory structure.
-    
+
     Only copies files to locations where the target directory already exists.
     Warns and skips files where target directories don't exist.
-    
+
     Args:
         repo_dir: Source repository directory
         target_dir: Target directory to copy to
         file_pattern: File pattern to search for (e.g., "AGENTS.md")
-    
+
     Returns:
         List of copied file paths relative to target_dir
     """
     copied_items = []
-    
+
     # Find all matching files recursively
     matching_files = list(repo_dir.rglob(file_pattern))
-    
+
     for source_file in matching_files:
         # Calculate relative path from repo root
         relative_path = source_file.relative_to(repo_dir)
         target_file = target_dir / relative_path
-        
+
         # Check if target directory already exists
         target_parent = target_file.parent
         if not target_parent.exists():
-            logger.warning(
-                "Target directory does not exist, skipping file copy",
+            log.warning(
+                "target directory does not exist, skipping file copy",
                 target_directory=str(target_parent),
-                file=str(relative_path)
+                file=str(relative_path),
             )
             continue
-            
-        logger.info(
-            "Copying recursive file",
-            source=str(source_file),
-            target=str(target_file)
+
+        log.info(
+            "copying recursive file", source=str(source_file), target=str(target_file)
         )
-        
+
         # Copy file (parent directory already exists)
         target_file.write_bytes(source_file.read_bytes())
         copied_items.append(str(relative_path))
-    
+
     return copied_items
 
 
 def copy_directory_contents(
-    source_dir: Path, target_dir: Path, exclude_patterns: List[str]
+    source_dir: Path,
+    target_dir: Path,
+    exclude_patterns: list[str],
+    include_patterns: list[str] = [],
 ):
     """Recursively copy directory contents, excluding specified patterns."""
     for item in source_dir.rglob("*"):
@@ -216,6 +247,7 @@ def copy_directory_contents(
 
             # Check if file matches any exclude pattern
             should_exclude = False
+            pattern = ""
             for pattern in exclude_patterns:
                 if pattern.endswith("/*"):
                     # Pattern like "workflows/*" - exclude if path starts with "workflows/"
@@ -228,9 +260,25 @@ def copy_directory_contents(
                     break
 
             if should_exclude:
-                logger.debug("Excluding file", file=relative_str, pattern=pattern)
+                log.debug("excluding file", file=relative_str, pattern=pattern)
                 continue
 
+            # Check if file matches any include pattern (if any provided)
+            if include_patterns:
+                matched_include = False
+                for include_pattern in include_patterns:
+                    # Match against filename only, or full relative path
+                    if item.match(include_pattern):
+                        matched_include = True
+                        break
+
+                if not matched_include:
+                    log.debug(
+                        "skipping file (not matched in include_patterns)",
+                        file=relative_str,
+                    )
+                    continue
+
             target_file = target_dir / relative_path
             target_file.parent.mkdir(parents=True, exist_ok=True)
             target_file.write_bytes(item.read_bytes())
@@ -238,7 +286,7 @@ def copy_directory_contents(
 
 def download_main(
     instruction_types: Annotated[
-        List[str],
+        list[str] | None,
         typer.Argument(
             help="Types of instructions to download (cursor, github, gemini, claude, agent, agents). Downloads everything by default."
         ),
@@ -252,9 +300,6 @@ def download_main(
     target_dir: Annotated[
         str, typer.Option("--target", "-t", help="Target directory to download to")
     ] = ".",
-    verbose: Annotated[
-        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
-    ] = False,
 ):
     """Download LLM instruction files from GitHub repositories.
 
@@ -279,12 +324,6 @@ def download_main(
     # Download to a specific directory
     llm_ide_rules download --target ./my-project
     """
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
-
     # Use default types if none specified
     if not instruction_types:
         instruction_types = DEFAULT_TYPES
@@ -292,17 +331,19 @@ def download_main(
     # Validate instruction types
     invalid_types = [t for t in instruction_types if t not in INSTRUCTION_TYPES]
     if invalid_types:
-        logger.error(
-            "Invalid instruction types",
+        log.error(
+            "invalid instruction types",
             invalid_types=invalid_types,
             valid_types=list(INSTRUCTION_TYPES.keys()),
         )
+        error_msg = f"Invalid instruction types: {', '.join(invalid_types)}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         raise typer.Exit(1)
 
     target_path = Path(target_dir).resolve()
 
-    logger.info(
-        "Starting download",
+    log.info(
+        "starting download",
         repo=repo,
         branch=branch,
         instruction_types=instruction_types,
@@ -316,13 +357,58 @@ def download_main(
         # Copy instruction files
         copied_items = copy_instruction_files(repo_dir, instruction_types, target_path)
 
+        # Check for source files (instructions.md, commands.md) and copy them if available
+        # These are needed for 'explode' logic
+        source_files = ["instructions.md", "commands.md"]
+        sources_copied = False
+
+        # Only copy source files if we have at least one agent that uses explode
+        has_explode_agent = any(t in VALID_AGENTS for t in instruction_types)
+
+        if has_explode_agent:
+            for source_file in source_files:
+                src = repo_dir / source_file
+                dst = target_path / source_file
+                if src.exists():
+                    log.info("copying source file", source=str(src), target=str(dst))
+                    dst.parent.mkdir(parents=True, exist_ok=True)
+                    dst.write_bytes(src.read_bytes())
+                    copied_items.append(source_file)
+                    sources_copied = True
+
+        # Generate rule files locally for supported agents
+        explodable_agents = [t for t in instruction_types if t in VALID_AGENTS]
+
+        if explodable_agents:
+            if not sources_copied:
+                # Check if they existed in target already?
+                if not (target_path / "instructions.md").exists():
+                    log.warning(
+                        "source file instructions.md missing, generation might fail"
+                    )
+
+            for agent in explodable_agents:
+                log.info("generating rules locally", agent=agent)
+                try:
+                    explode_implementation(
+                        input_file="instructions.md",
+                        agent=agent,
+                        working_dir=target_path,
+                    )
+                    copied_items.append(f"(generated) {agent} rules")
+                except Exception as e:
+                    log.error("failed to generate rules", agent=agent, error=str(e))
+                    typer.echo(
+                        f"Warning: Failed to generate rules for {agent}: {e}", err=True
+                    )
+
         if copied_items:
-            logger.info("Download completed successfully", copied_items=copied_items)
-            typer.echo(f"Downloaded {len(copied_items)} items to {target_path}:")
+            success_msg = f"Downloaded/Generated items in {target_path}:"
+            typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
             for item in copied_items:
                 typer.echo(f"  - {item}")
         else:
-            logger.warning("No files were copied")
+            log.warning("no files were copied or generated")
             typer.echo("No matching instruction files found in the repository.")
 
     finally: