llm-ide-rules 0.16.0__py3-none-any.whl

llm_ide_rules/__init__.py

@@ -0,0 +1,115 @@
+"""LLM Rules CLI package for managing IDE prompts and rules."""
+
+import os
+
+if "LOG_LEVEL" not in os.environ:
+    os.environ["LOG_LEVEL"] = "WARNING"
+
+from typing import Annotated
+
+import typer
+
+from llm_ide_rules.commands.config import config_main
+from llm_ide_rules.commands.delete import delete_main
+from llm_ide_rules.commands.download import download_main
+from llm_ide_rules.commands.explode import explode_main
+from llm_ide_rules.commands.exploded import exploded_main
+from llm_ide_rules.commands.ignores import ignores_main
+from llm_ide_rules.commands.implode import (
+    agents,
+    antigravity,
+    claude,
+    cursor,
+    github,
+    grok,
+    opencode,
+)
+from llm_ide_rules.version import __version__
+
+
+def version_callback(value: bool):
+    """Callback to display the version and exit."""
+    if value:
+        print(f"llm-ide-rules version {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="llm_ide_rules",
+    help="CLI tool for managing LLM IDE prompts and rules",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def main_callback(
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose", "-v", help="Enable verbose logging (sets LOG_LEVEL=DEBUG)"
+        ),
+    ] = False,
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            help="Show the version and exit",
+            callback=version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+):
+    """Global CLI options."""
+    if verbose:
+        os.environ["LOG_LEVEL"] = "DEBUG"
+        import structlog_config
+
+        structlog_config.configure_logger()
+
+
+# Add commands directly
+app.command("explode", help="Convert instruction file to separate rule files")(
+    explode_main
+)
+app.command("exploded", help="List clients that were exploded")(exploded_main)
+app.command("ignores", help="Generate list of files to ignore based on instructions")(
+    ignores_main
+)
+app.command("download", help="Download LLM instruction files from GitHub repositories")(
+    download_main
+)
+app.command("delete", help="Remove downloaded LLM instruction files")(delete_main)
+app.command("config", help="Configure agents to use AGENTS.md")(config_main)
+
+# Create implode sub-typer
+implode_app = typer.Typer(help="Bundle rule files into a single instruction file")
+implode_app.command(
+    "cursor", help="Bundle Cursor rules and commands into a single file"
+)(cursor)
+implode_app.command(
+    "github", help="Bundle GitHub/Copilot instructions and prompts into a single file"
+)(github)
+implode_app.command(
+    "claude", help="Bundle Claude Code rules and commands into single files"
+)(claude)
+implode_app.command(
+    "antigravity",
+    help="Bundle Antigravity (.agents) rules and skills into single files",
+)(antigravity)
+implode_app.command(
+    "grok", help="Bundle Grok (.agents) rules and skills into single files"
+)(grok)
+implode_app.command("opencode", help="Bundle OpenCode commands into a single file")(
+    opencode
+)
+implode_app.command("agents", help="Bundle AGENTS.md files into a single file")(agents)
+app.add_typer(implode_app, name="implode")
+
+
+def main():
+    """Main entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

llm_ide_rules/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running llm_ide_rules with python -m llm_ide_rules."""
+
+from llm_ide_rules import main
+
+if __name__ == "__main__":
+    main()

llm_ide_rules/agents/__init__.py

@@ -0,0 +1,45 @@
+"""Agent registry for LLM IDE rules."""
+
+from llm_ide_rules.agents.agents import AgentsAgent
+from llm_ide_rules.agents.antigravity import AntigravityAgent
+from llm_ide_rules.agents.base import BaseAgent
+from llm_ide_rules.agents.claude import ClaudeAgent
+from llm_ide_rules.agents.cursor import CursorAgent
+from llm_ide_rules.agents.github import GitHubAgent
+from llm_ide_rules.agents.grok import GrokAgent
+from llm_ide_rules.agents.opencode import OpenCodeAgent
+from llm_ide_rules.agents.vscode import VSCodeAgent
+
+AGENTS: dict[str, type[BaseAgent]] = {
+    "cursor": CursorAgent,
+    "github": GitHubAgent,
+    "claude": ClaudeAgent,
+    "opencode": OpenCodeAgent,
+    "agents": AgentsAgent,
+    "vscode": VSCodeAgent,
+    "antigravity": AntigravityAgent,
+    "grok": GrokAgent,
+}
+
+# Aliases for user-friendly names
+AGENT_ALIASES: dict[str, str] = {}
+
+
+def get_agent(name: str) -> BaseAgent:
+    """Get an agent instance by name."""
+    if name in AGENT_ALIASES:
+        name = AGENT_ALIASES[name]
+    if name not in AGENTS:
+        raise ValueError(f"Unknown agent: {name}. Available: {list(AGENTS.keys())}")
+    return AGENTS[name]()
+
+
+def get_all_agents() -> list[BaseAgent]:
+    """Get instances of all registered agents."""
+    seen: set[type[BaseAgent]] = set()
+    result: list[BaseAgent] = []
+    for agent_cls in AGENTS.values():
+        if agent_cls not in seen:
+            seen.add(agent_cls)
+            result.append(agent_cls())
+    return result

llm_ide_rules/agents/agents.py

@@ -0,0 +1,179 @@
+"""Agents documentation agent implementation."""
+
+from pathlib import Path
+
+import typer
+
+from llm_ide_rules.agents.base import BaseAgent
+
+
+class AgentsAgent(BaseAgent):
+    """Agent for generating AGENTS.md documentation."""
+
+    name = "agents"
+    rules_dir = None
+    commands_dir = None
+    rule_extension = None
+    command_extension = None
+
+    def bundle_rules(
+        self,
+        output_file: Path,
+        section_globs: dict[str, str | None] | None = None,
+        filename: str = "AGENTS.md",
+    ) -> bool:
+        """Bundle all AGENTS.md files into a single output file."""
+        base_dir = output_file.parent
+        # Find all AGENTS.md files recursively
+        agents_files = list(base_dir.rglob(filename))
+        if not agents_files:
+            return False
+
+        # Sort files: root first, then by depth and name
+        root_agents = [f for f in agents_files if f.parent == base_dir]
+        subdir_agents = sorted(
+            [f for f in agents_files if f.parent != base_dir],
+            key=lambda f: f.as_posix(),
+        )
+
+        all_agents = root_agents + subdir_agents
+        content_parts: list[str] = []
+        processed_sections: set[str] = set()
+
+        for agents_file in all_agents:
+            content = agents_file.read_text().strip()
+            if not content:
+                continue
+
+            from llm_ide_rules.markdown_parser import parse_sections
+
+            general, sections = parse_sections(content)
+
+            # Only include general instructions once (from root)
+            if general and agents_file.parent == base_dir:
+                from llm_ide_rules.agents.base import trim_content
+
+                trimmed = trim_content(general)
+                if trimmed:
+                    content_parts.extend(trimmed)
+                    content_parts.append("\n\n")
+
+            for section_name, section_data in sections.items():
+                if section_name in processed_sections:
+                    continue
+
+                processed_sections.add(section_name)
+                section_content = section_data.content
+
+                # Reconstruct header and globs if it's from a subdirectory
+                content_parts.append(f"## {section_name}\n\n")
+
+                if agents_file.parent != base_dir:
+                    rel_dir = agents_file.parent.relative_to(base_dir)
+                    content_parts.append(f"globs: {rel_dir.as_posix()}/**/*\n\n")
+
+                from llm_ide_rules.agents.base import trim_content
+
+                trimmed = trim_content(section_content)
+                # Remove the section header from content as we already added it
+                if trimmed and trimmed[0].startswith("## "):
+                    trimmed = trimmed[1:]
+                    trimmed = trim_content(trimmed)
+
+                if trimmed:
+                    content_parts.extend(trimmed)
+                    content_parts.append("\n\n")
+
+        if not content_parts:
+            return False
+
+        self._write_bundled_content(output_file, "".join(content_parts))
+        return True
+
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """Agents doesn't support bundling commands."""
+        return False
+
+    def write_rule(
+        self,
+        content_lines: list[str],
+        filename: str,
+        rules_dir: Path,
+        glob_pattern: str | None = None,
+        description: str | None = None,
+    ) -> None:
+        """Agents doesn't support writing rules."""
+
+    def write_command(
+        self,
+        content_lines: list[str],
+        filename: str,
+        commands_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """Agents doesn't support writing commands."""
+
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+        section_globs: dict[str, str | None] | None = None,
+        filename: str = "AGENTS.md",
+    ) -> None:
+        """Generate AGENTS.md files, potentially distributed based on globs."""
+        if not section_globs:
+            # Fallback to single root AGENTS.md
+            content = self.build_root_doc_content(general_lines, rules_sections)
+            if content.strip():
+                (output_dir / filename).write_text(content)
+            return
+
+        # Group rules by target directory
+        rules_by_dir: dict[Path, dict[str, list[str]]] = {}
+
+        # Always include root directory for rules without specific directory targets
+        rules_by_dir[output_dir] = {}
+
+        from llm_ide_rules.utils import resolve_target_dir
+
+        for section_name, lines in rules_sections.items():
+            glob_pattern = section_globs.get(section_name)
+            target_dir = resolve_target_dir(output_dir, glob_pattern)
+
+            if target_dir != output_dir and glob_pattern and "**" in glob_pattern:
+                prefix = glob_pattern.split("**")[0].strip("/")
+                potential_dir = output_dir / prefix
+                if target_dir != potential_dir:
+                    rel_potential = potential_dir.relative_to(output_dir)
+                    rel_actual = target_dir.relative_to(output_dir)
+                    typer.secho(
+                        f"Warning: Directory '{rel_potential}' for section '{section_name}' does not exist. "
+                        f"Placing in '{rel_actual}' instead.",
+                        fg=typer.colors.YELLOW,
+                        err=True,
+                    )
+
+            if target_dir not in rules_by_dir:
+                rules_by_dir[target_dir] = {}
+
+            rules_by_dir[target_dir][section_name] = lines
+
+        # Generate AGENTS.md for each directory
+        for target_dir, sections in rules_by_dir.items():
+            if not sections:
+                continue
+
+            # Only include general instructions in the root AGENTS.md
+            current_general_lines = general_lines if target_dir == output_dir else []
+
+            content = self.build_root_doc_content(current_general_lines, sections)
+            if content.strip():
+                (target_dir / filename).write_text(content)
+
+    def detect(self, base_dir: Path) -> bool:
+        "detect if AGENTS.md is in use in the given directory"
+        return (base_dir / "AGENTS.md").exists()

llm_ide_rules/agents/antigravity.py

@@ -0,0 +1,19 @@
+"""Antigravity CLI agent implementation."""
+
+from pathlib import Path
+
+from llm_ide_rules.agents.dotagents import DotAgentsBaseAgent
+
+
+class AntigravityAgent(DotAgentsBaseAgent):
+    """Agent for Antigravity CLI."""
+
+    name = "antigravity"
+
+    def detect(self, base_dir: Path) -> bool:
+        "detect if Antigravity is in use in the given directory"
+        return (
+            super().detect(base_dir)
+            or (base_dir / ".gemini").exists()
+            or (base_dir / ".antigravity").exists()
+        )

llm_ide_rules/agents/base.py

@@ -0,0 +1,299 @@
+"""Base agent class and shared utilities for LLM IDE rules."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from llm_ide_rules.constants import header_to_filename
+
+
+class BaseAgent(ABC):
+    """Base class for all IDE agents."""
+
+    name: str
+    rules_dir: str | None = None
+    commands_dir: str | None = None
+    rule_extension: str | None = None
+    command_extension: str | None = None
+
+    @abstractmethod
+    def bundle_rules(
+        self,
+        output_file: Path,
+        section_globs: dict[str, str | None] | None = None,
+        filename: str = "AGENTS.md",
+    ) -> bool:
+        """Bundle rule files into a single output file."""
+        ...
+
+    @abstractmethod
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """Bundle command files into a single output file."""
+        ...
+
+    @abstractmethod
+    def write_rule(
+        self,
+        content_lines: list[str],
+        filename: str,
+        rules_dir: Path,
+        glob_pattern: str | None = None,
+        description: str | None = None,
+    ) -> None:
+        """Write a single rule file."""
+        ...
+
+    @abstractmethod
+    def write_command(
+        self,
+        content_lines: list[str],
+        filename: str,
+        commands_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """Write a single command file."""
+        ...
+
+    def detect(self, base_dir: Path) -> bool:
+        "detect if this agent is in use in the given directory"
+        return False
+
+    def configure_agents_md(self, base_dir: Path) -> bool:
+        """Configure the agent to use AGENTS.md as context (default: no-op).
+
+        Returns:
+            bool: True if configuration was applied, False otherwise.
+        """
+        return False
+
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+        section_globs: dict[str, str | None] | None = None,
+        filename: str = "AGENTS.md",
+    ) -> None:
+        """Generate a root documentation file (e.g. CLAUDE.md) if supported."""
+        return
+
+    def build_root_doc_content(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+    ) -> str:
+        """Build the content string for a root documentation file by aggregating rules."""
+        content = []
+
+        # Add general instructions
+        if general_lines:
+            trimmed = trim_content(general_lines)
+            if trimmed:
+                content.extend(trimmed)
+                content.append("\n\n")
+
+        # Add sections in document order (dict maintains insertion order in Python 3.7+)
+        for lines in rules_sections.values():
+            trimmed = trim_content(lines)
+            if trimmed:
+                content.extend(trimmed)
+                content.append("\n\n")
+
+        return "".join(content).strip() + "\n" if content else ""
+
+    def get_rules_path(self, base_dir: Path) -> Path:
+        """Get the full path to the rules directory."""
+        if not self.rules_dir:
+            raise NotImplementedError(f"{self.name} does not support rules")
+        return base_dir / self.rules_dir
+
+    def get_commands_path(self, base_dir: Path) -> Path:
+        """Get the full path to the commands directory."""
+        if not self.commands_dir:
+            raise NotImplementedError(f"{self.name} does not support commands")
+        return base_dir / self.commands_dir
+
+    def _write_bundled_content(self, output_file: Path, content: str) -> None:
+        """Write bundled content to output file, preserving custom instructions after marker."""
+        marker = "<!-- END CLONED INSTRUCTIONS -->"
+        local_custom_content = ""
+
+        if output_file.exists():
+            try:
+                current_content = output_file.read_text(encoding="utf-8")
+                if marker in current_content:
+                    local_custom_content = current_content.split(marker, 1)[1]
+            except OSError:
+                # Fallback if file cannot be read
+                pass
+
+        if marker not in content:
+            # Ensure marker is present at the end of the bundled content
+            content = content.rstrip() + f"\n\n{marker}\n"
+
+        output_file.write_text(content + local_custom_content, encoding="utf-8")
+
+
+def strip_yaml_frontmatter(text: str) -> str:
+    """Strip YAML frontmatter from text."""
+    lines = text.splitlines()
+    if lines and lines[0].strip() == "---":
+        for i in range(1, len(lines)):
+            if lines[i].strip() == "---":
+                return "\n".join(lines[i + 1 :]).lstrip("\n")
+    return text
+
+
+def strip_header(text: str) -> str:
+    """Remove the first markdown header (## Header) from text if present."""
+    lines = text.splitlines()
+    if lines and lines[0].startswith("## "):
+        remaining_lines = lines[1:]
+        while remaining_lines and not remaining_lines[0].strip():
+            remaining_lines = remaining_lines[1:]
+        return "\n".join(remaining_lines)
+    return text
+
+
+def get_ordered_files(
+    file_list: list[Path], section_globs_keys: list[str] | None = None
+) -> list[Path]:
+    """Order files based on section_globs key order, with unmapped files at the end.
+
+    If section_globs_keys is None, returns files sorted alphabetically.
+    """
+    if not section_globs_keys:
+        return sorted(file_list, key=lambda p: p.name)
+
+    file_dict = {f.stem: f for f in file_list}
+    ordered_files = []
+
+    for section_name in section_globs_keys:
+        filename = header_to_filename(section_name)
+        if filename in file_dict:
+            ordered_files.append(file_dict[filename])
+            del file_dict[filename]
+
+    remaining_files = sorted(file_dict.values(), key=lambda p: p.name)
+    ordered_files.extend(remaining_files)
+
+    return ordered_files
+
+
+def get_ordered_files_github(
+    file_list: list[Path], section_globs_keys: list[str] | None = None
+) -> list[Path]:
+    """Order GitHub instruction files, handling .instructions suffix.
+
+    If section_globs_keys is None, returns files sorted alphabetically.
+    """
+    if not section_globs_keys:
+        return sorted(file_list, key=lambda p: p.name)
+
+    file_dict = {}
+    for f in file_list:
+        base_stem = f.stem.replace(".instructions", "")
+        file_dict[base_stem] = f
+
+    ordered_files = []
+
+    for section_name in section_globs_keys:
+        filename = header_to_filename(section_name)
+        if filename in file_dict:
+            ordered_files.append(file_dict[filename])
+            del file_dict[filename]
+
+    remaining_files = sorted(file_dict.values(), key=lambda p: p.name)
+    ordered_files.extend(remaining_files)
+
+    return ordered_files
+
+
+def resolve_header_from_stem(stem: str, section_globs: dict[str, str | None]) -> str:
+    """Return the canonical header for a given filename stem.
+
+    Prefer exact header names from section_globs (preserves acronyms like FastAPI, TypeScript).
+    Fallback to title-casing the filename when not found in section_globs.
+    """
+    for section_name in section_globs:
+        if header_to_filename(section_name) == stem:
+            return section_name
+
+    return stem.replace("-", " ").title()
+
+
+def trim_content(content_lines: list[str]) -> list[str]:
+    """Remove leading and trailing empty lines from content."""
+    start = 0
+    for i, line in enumerate(content_lines):
+        if line.strip():
+            start = i
+            break
+    else:
+        return []
+
+    end = len(content_lines)
+    for i in range(len(content_lines) - 1, -1, -1):
+        if content_lines[i].strip():
+            end = i + 1
+            break
+
+    return content_lines[start:end]
+
+
+def write_rule_file(path: Path, header_yaml: str, content_lines: list[str]) -> None:
+    """Write a rule file with front matter and content."""
+    trimmed_content = trim_content(content_lines)
+    output = header_yaml.strip() + "\n" + "".join(trimmed_content)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(output)
+
+
+def replace_header_with_proper_casing(
+    content_lines: list[str], proper_header: str
+) -> list[str]:
+    """Replace the first header in content with the properly cased version."""
+    if not content_lines:
+        return content_lines
+
+    for i, line in enumerate(content_lines):
+        if line.startswith("## "):
+            content_lines[i] = f"## {proper_header}\n"
+            break
+
+    return content_lines
+
+
+def extract_description_and_filter_content(
+    content_lines: list[str], default_description: str
+) -> tuple[str, list[str]]:
+    """Extract description from first non-empty line that starts with 'Description:' and return filtered content."""
+    trimmed_content = trim_content(content_lines)
+    description = ""
+    description_line = None
+
+    for i, line in enumerate(trimmed_content):
+        stripped_line = line.strip()
+        if (
+            stripped_line
+            and not stripped_line.startswith("#")
+            and not stripped_line.startswith("##")
+        ):
+            if stripped_line.startswith("Description:"):
+                description = stripped_line[len("Description:") :].strip()
+                description_line = i
+                break
+            else:
+                break
+
+    if description and description_line is not None:
+        filtered_content = (
+            trimmed_content[:description_line] + trimmed_content[description_line + 1 :]
+        )
+        filtered_content = trim_content(filtered_content)
+    else:
+        filtered_content = trimmed_content
+
+    return description, filtered_content