llm-ide-rules 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

llm_ide_rules/agents/gemini.py

@@ -0,0 +1,161 @@
+"""Gemini CLI agent implementation."""
+
+import json
+from pathlib import Path
+
+from llm_ide_rules.agents.base import (
+    BaseAgent,
+    get_ordered_files,
+    resolve_header_from_stem,
+    strip_toml_metadata,
+    trim_content,
+    extract_description_and_filter_content,
+)
+from llm_ide_rules.mcp import McpServer
+
+
+class GeminiAgent(BaseAgent):
+    """Agent for Gemini CLI."""
+
+    name = "gemini"
+    rules_dir = None
+    commands_dir = ".gemini/commands"
+    rule_extension = None
+    command_extension = ".toml"
+
+    mcp_global_path = ".gemini/settings.json"
+    mcp_project_path = ".gemini/settings.json"
+
+    def bundle_rules(
+        self, output_file: Path, section_globs: dict[str, str | None]
+    ) -> bool:
+        """Gemini CLI doesn't support rules, only commands."""
+        return False
+
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None]
+    ) -> bool:
+        """Bundle Gemini CLI command files (.toml) 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()))
+
+        content_parts: list[str] = []
+        for command_file in ordered_commands:
+            content = command_file.read_text().strip()
+            if not content:
+                continue
+
+            content = strip_toml_metadata(content)
+            header = resolve_header_from_stem(command_file.stem, section_globs)
+            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:
+        """Gemini CLI 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 a Gemini CLI command file (.toml) with TOML format."""
+        import tomli_w
+
+        extension = self.command_extension or ".toml"
+        filepath = commands_dir / f"{filename}{extension}"
+
+        description, filtered_content = extract_description_and_filter_content(
+            content_lines, ""
+        )
+
+        final_content = []
+        found_header = False
+        for line in filtered_content:
+            if not found_header and line.startswith("## "):
+                found_header = True
+                continue
+            final_content.append(line)
+
+        final_content = trim_content(final_content)
+        content_str = "".join(final_content).strip()
+
+        desc = description if description else (section_name or filename)
+
+        # Construct dict and dump to TOML
+        data = {
+            "description": desc,
+            "prompt": content_str + "\n",  # Ensure trailing newline in multiline string
+        }
+
+        # tomli-w will handle escaping and multiline strings automatically
+        output = tomli_w.dumps(data)
+        filepath.write_text(output)
+
+    def transform_mcp_server(self, server: McpServer) -> dict:
+        """Transform unified server to Gemini format (uses httpUrl instead of url)."""
+        if server.url:
+            result: dict = {"httpUrl": server.url}
+            if server.env:
+                result["env"] = server.env
+            return result
+
+        result: dict = {"command": server.command, "args": server.args or []}
+        if server.env:
+            result["env"] = server.env
+        return result
+
+    def reverse_transform_mcp_server(self, name: str, config: dict) -> McpServer:
+        """Transform Gemini config back to unified format."""
+        if "httpUrl" in config:
+            return McpServer(
+                url=config["httpUrl"],
+                env=config.get("env"),
+            )
+
+        return McpServer(
+            command=config["command"],
+            args=config.get("args", []),
+            env=config.get("env"),
+        )
+
+    def write_mcp_config(self, servers: dict, path: Path) -> None:
+        """Write MCP config to path, merging with existing settings."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        existing = {}
+        if path.exists():
+            existing = json.loads(path.read_text())
+
+        existing[self.mcp_root_key] = servers
+        path.write_text(json.dumps(existing, indent=2))

llm_ide_rules/agents/github.py

@@ -0,0 +1,207 @@
+"""GitHub/Copilot agent implementation."""
+
+from pathlib import Path
+
+from llm_ide_rules.agents.base import (
+    BaseAgent,
+    get_ordered_files_github,
+    resolve_header_from_stem,
+    strip_yaml_frontmatter,
+    strip_header,
+    write_rule_file,
+    extract_description_and_filter_content,
+)
+from llm_ide_rules.constants import header_to_filename
+from llm_ide_rules.mcp import McpServer
+
+
+class GitHubAgent(BaseAgent):
+    """Agent for GitHub Copilot."""
+
+    name = "github"
+    rules_dir = ".github/instructions"
+    commands_dir = ".github/prompts"
+    rule_extension = ".instructions.md"
+    command_extension = ".prompt.md"
+
+    mcp_global_path = ".copilot/mcp-config.json"
+    mcp_project_path = ".copilot/mcp-config.json"
+
+    def bundle_rules(
+        self, output_file: Path, section_globs: dict[str, str | None]
+    ) -> bool:
+        """Bundle GitHub instruction files into a single output file."""
+        rules_dir = self.rules_dir
+        if not rules_dir:
+            return False
+
+        base_dir = output_file.parent
+        instructions_path = base_dir / rules_dir
+        copilot_general = base_dir / ".github" / "copilot-instructions.md"
+
+        rule_ext = self.rule_extension
+        if not rule_ext:
+            return False
+
+        instr_files = list(instructions_path.glob(f"*{rule_ext}"))
+
+        ordered_instructions = get_ordered_files_github(
+            instr_files, list(section_globs.keys())
+        )
+
+        content_parts: list[str] = []
+        if copilot_general.exists():
+            content = copilot_general.read_text().strip()
+            if content:
+                content_parts.append(content)
+                content_parts.append("\n\n")
+
+        for instr_file in ordered_instructions:
+            content = instr_file.read_text().strip()
+            if not content:
+                continue
+
+            content = strip_yaml_frontmatter(content)
+            content = strip_header(content)
+            base_stem = instr_file.stem.replace(".instructions", "")
+            header = resolve_header_from_stem(base_stem, section_globs)
+            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 bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None]
+    ) -> bool:
+        """Bundle GitHub prompt files into a single output file."""
+        commands_dir = self.commands_dir
+        if not commands_dir:
+            return False
+
+        prompts_path = output_file.parent / commands_dir
+        if not prompts_path.exists():
+            return False
+
+        command_ext = self.command_extension
+        if not command_ext:
+            return False
+
+        prompt_files = list(prompts_path.glob(f"*{command_ext}"))
+        if not prompt_files:
+            return False
+
+        prompt_dict = {}
+        for f in prompt_files:
+            base_stem = f.stem.replace(".prompt", "")
+            prompt_dict[base_stem] = f
+
+        ordered_prompts = []
+        for section_name in section_globs.keys():
+            filename = header_to_filename(section_name)
+            if filename in prompt_dict:
+                ordered_prompts.append(prompt_dict[filename])
+                del prompt_dict[filename]
+
+        remaining_prompts = sorted(prompt_dict.values(), key=lambda p: p.name)
+        ordered_prompts.extend(remaining_prompts)
+
+        content_parts: list[str] = []
+        for prompt_file in ordered_prompts:
+            content = prompt_file.read_text().strip()
+            if not content:
+                continue
+
+            content = strip_yaml_frontmatter(content)
+            content = strip_header(content)
+            base_stem = prompt_file.stem.replace(".prompt", "")
+            header = resolve_header_from_stem(base_stem, section_globs)
+            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:
+        """Write a GitHub instruction file (.instructions.md) with YAML frontmatter."""
+        extension = self.rule_extension or ".instructions.md"
+        filepath = rules_dir / f"{filename}{extension}"
+
+        if glob_pattern and glob_pattern != "manual":
+            header_yaml = f"""---
+applyTo: "{glob_pattern}"
+---
+"""
+        else:
+            header_yaml = ""
+
+        write_rule_file(filepath, header_yaml, content_lines)
+
+    def write_command(
+        self,
+        content_lines: list[str],
+        filename: str,
+        commands_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """Write a GitHub prompt file (.prompt.md) with YAML frontmatter."""
+        extension = self.command_extension or ".prompt.md"
+        filepath = commands_dir / f"{filename}{extension}"
+
+        description, filtered_content = extract_description_and_filter_content(
+            content_lines, ""
+        )
+
+        frontmatter = f"---\nmode: 'agent'\ndescription: '{description}'\n---\n"
+        filepath.write_text(frontmatter + "".join(filtered_content))
+
+    def write_general_instructions(
+        self, content_lines: list[str], base_dir: Path
+    ) -> None:
+        """Write the general copilot-instructions.md file (no frontmatter)."""
+        filepath = base_dir / ".github" / "copilot-instructions.md"
+        write_rule_file(filepath, "", content_lines)
+
+    def transform_mcp_server(self, server: McpServer) -> dict:
+        """Transform unified server to GitHub Copilot format (adds type and tools)."""
+        base: dict = {"tools": ["*"]}
+        if server.env:
+            base["env"] = server.env
+
+        if server.url:
+            return {"type": "http", "url": server.url, **base}
+
+        return {
+            "type": "local",
+            "command": server.command,
+            "args": server.args or [],
+            **base,
+        }
+
+    def reverse_transform_mcp_server(self, name: str, config: dict) -> McpServer:
+        """Transform GitHub Copilot config back to unified format."""
+        if config.get("type") == "http":
+            return McpServer(
+                url=config["url"],
+                env=config.get("env"),
+            )
+
+        return McpServer(
+            command=config["command"],
+            args=config.get("args", []),
+            env=config.get("env"),
+        )

llm_ide_rules/agents/opencode.py

@@ -0,0 +1,126 @@
+"""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]
+    ) -> bool:
+        """OpenCode doesn't support rules."""
+        return False
+
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | 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()))
+
+        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)
+            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))