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

llm_ide_rules/agents/cursor.py

@@ -0,0 +1,199 @@
+"""Cursor IDE agent implementation."""
+
+from pathlib import Path
+
+from llm_ide_rules.agents.base import (
+    BaseAgent,
+    get_ordered_files,
+    resolve_header_from_stem,
+    strip_yaml_frontmatter,
+    strip_header,
+    trim_content,
+    write_rule_file,
+    extract_description_and_filter_content,
+)
+
+
+class CursorAgent(BaseAgent):
+    """Agent for Cursor IDE."""
+
+    name = "cursor"
+    rules_dir = ".cursor/rules"
+    commands_dir = ".cursor/commands"
+    rule_extension = ".mdc"
+    command_extension = ".md"
+
+    mcp_global_path = ".cursor/mcp.json"
+    mcp_project_path = ".cursor/mcp.json"
+
+    def bundle_rules(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """Bundle Cursor rule files (.mdc) into a single output file."""
+        rules_dir = self.rules_dir
+        if not rules_dir:
+            return False
+
+        rules_path = output_file.parent / rules_dir
+
+        rule_ext = self.rule_extension
+        if not rule_ext:
+            return False
+
+        rule_files = list(rules_path.glob(f"*{rule_ext}"))
+
+        general = [f for f in rule_files if f.stem == "general"]
+        others = [f for f in rule_files if f.stem != "general"]
+
+        ordered_others = get_ordered_files(
+            others, list(section_globs.keys()) if section_globs else None
+        )
+        ordered = general + ordered_others
+
+        content_parts: list[str] = []
+        for rule_file in ordered:
+            file_content = rule_file.read_text().strip()
+            if not file_content:
+                continue
+
+            # Extract header from file content before stripping it
+            lines = file_content.splitlines()
+            extracted_header = None
+            for line in lines:
+                if line.startswith("## "):
+                    extracted_header = line[3:].strip()
+                    break
+
+            content = strip_yaml_frontmatter(file_content)
+            content = strip_header(content)
+
+            # Use extracted header if available, otherwise resolve from filename
+            if extracted_header:
+                header = extracted_header
+            else:
+                header = resolve_header_from_stem(
+                    rule_file.stem, section_globs if section_globs else {}
+                )
+
+            if rule_file.stem != "general":
+                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] | None = None
+    ) -> bool:
+        """Bundle Cursor 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
+
+        command_ext = self.command_extension
+        if not command_ext:
+            return False
+
+        command_files = list(commands_path.glob(f"*{command_ext}"))
+        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:
+        """Write a Cursor rule file (.mdc) with YAML frontmatter."""
+        extension = self.rule_extension or ".mdc"
+        filepath = rules_dir / f"{filename}{extension}"
+
+        if glob_pattern and glob_pattern != "manual":
+            header_yaml = f"""---
+description:
+globs: {glob_pattern}
+alwaysApply: false
+---
+"""
+        elif glob_pattern == "manual":
+            header_yaml = """---
+description:
+alwaysApply: false
+---
+"""
+        else:
+            header_yaml = """---
+description:
+alwaysApply: true
+---
+"""
+        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 Cursor 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 write_prompt(
+        self,
+        content_lines: list[str],
+        filename: str,
+        prompts_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """Write a Cursor prompt file (.mdc) with optional frontmatter."""
+        extension = self.rule_extension or ".mdc"
+        filepath = prompts_dir / f"{filename}{extension}"
+
+        description, filtered_content = extract_description_and_filter_content(
+            content_lines, ""
+        )
+
+        output_parts: list[str] = []
+        if description:
+            output_parts.append(f"---\ndescription: {description}\n---\n")
+
+        output_parts.extend(filtered_content)
+        filepath.write_text("".join(output_parts))

llm_ide_rules/agents/gemini.py

@@ -0,0 +1,177 @@
+"""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] | None = 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] | None = 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()) 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
+
+            content = strip_toml_metadata(content)
+            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:
+        """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))
+
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+    ) -> None:
+        """Generate GEMINI.md from rules."""
+        content = self.build_root_doc_content(general_lines, rules_sections)
+        if content.strip():
+            (output_dir / "GEMINI.md").write_text(content)

llm_ide_rules/agents/github.py

@@ -0,0 +1,212 @@
+"""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] | None = 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()) if section_globs else None
+        )
+
+        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 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 bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = 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 = []
+        if section_globs:
+            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 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:
+        """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"),
+        )