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

llm_ide_rules/commands/explode.py

@@ -1,52 +1,34 @@
 """Explode command: Convert instruction file to separate rule files."""
 
-import os
-import sys
 from pathlib import Path
 from typing_extensions import Annotated
 
 import typer
-import structlog
-import logging
 
-from llm_ide_rules.constants import load_section_globs, header_to_filename
+from llm_ide_rules.agents import get_agent
+from llm_ide_rules.agents.base import (
+    BaseAgent,
+    replace_header_with_proper_casing,
+    write_rule_file,
+)
+from llm_ide_rules.log import log
+from llm_ide_rules.constants import load_section_globs, header_to_filename, VALID_AGENTS
 
-logger = structlog.get_logger()
 
-
-def generate_cursor_frontmatter(glob):
-    """Generate Cursor rule frontmatter for a given glob pattern."""
-    return f"""---
-description:
-globs: {glob}
-alwaysApply: false
----
-"""
-
-
-def generate_copilot_frontmatter(glob):
-    """Generate Copilot instruction frontmatter for a given glob pattern."""
-    return f"""---
-applyTo: "{glob}"
----
-"""
-
-
-def extract_general(lines):
-    """
-    Extract lines before the first section header '## '.
-    """
+def extract_general(lines: list[str]) -> list[str]:
+    """Extract lines before the first section header '## '."""
     general = []
     for line in lines:
         if line.startswith("## "):
             break
         general.append(line)
+
     return general
 
 
-def extract_section(lines, header):
-    """
-    Extract lines under a given section header until the next header or EOF.
+def extract_section(lines: list[str], header: str) -> list[str]:
+    """Extract lines under a given section header until the next header or EOF.
+
     Includes the header itself in the output.
     """
     content = []
@@ -58,200 +40,157 @@ def extract_section(lines, header):
             content.append(line)
         elif line.strip().lower() == header.lower():
             in_section = True
-            content.append(line)  # Include the header itself
-    return content
-
-
-def write_rule(path, header_yaml, content_lines):
-    """
-    Write a rule file with front matter and content.
-    """
-    trimmed_content = trim_content(content_lines)
-    with open(path, "w") as f:
-        f.write(header_yaml.strip() + "\n")
-        for line in trimmed_content:
-            f.write(line)
-
-
-def trim_content(content_lines):
-    """Remove leading and trailing empty lines from content."""
-    # Find first non-empty line
-    start = 0
-    for i, line in enumerate(content_lines):
-        if line.strip():
-            start = i
-            break
-    else:
-        # All lines are empty
-        return []
-
-    # Find last non-empty line
-    end = len(content_lines)
-    for i in range(len(content_lines) - 1, -1, -1):
-        if content_lines[i].strip():
-            end = i + 1
-            break
+            content.append(line)
 
-    return content_lines[start:end]
+    return content
 
 
-def replace_header_with_proper_casing(content_lines, proper_header):
-    """Replace the first header in content with the properly cased version."""
-    if not content_lines:
-        return content_lines
+def extract_all_sections(lines: list[str]) -> dict[str, list[str]]:
+    """Extract all sections from lines, returning dict of section_name -> content_lines."""
+    sections: dict[str, list[str]] = {}
+    current_section: str | None = None
+    current_content: list[str] = []
 
-    # Find and replace the first header line
-    for i, line in enumerate(content_lines):
+    for line in lines:
         if line.startswith("## "):
-            content_lines[i] = f"## {proper_header}\n"
-            break
-
-    return content_lines
-
-
-def extract_description_and_filter_content(content_lines, default_description):
-    """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
-
-    # Find the first non-empty, non-header line that starts with "Description:"
-    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:"):
-                # Extract the description text after "Description:"
-                description = stripped_line[len("Description:") :].strip()
-                description_line = i
-                break
-            else:
-                # Found a non-header line that doesn't start with Description:, stop looking
-                break
-
-    # Only use explicit descriptions - no fallback extraction
-    if description and description_line is not None:
-        # Remove the description line from content
-        filtered_content = (
-            trimmed_content[:description_line] + trimmed_content[description_line + 1 :]
-        )
-        # Trim again after removing description line
-        filtered_content = trim_content(filtered_content)
-    else:
-        # No description found, keep all content
-        filtered_content = trimmed_content
-
-    return description, filtered_content
-
+            if current_section:
+                sections[current_section] = current_content
 
-def write_cursor_prompt(content_lines, filename, prompts_dir, section_name=None):
-    """Write a Cursor prompt file with frontmatter including description."""
-    filepath = os.path.join(prompts_dir, filename + ".mdc")
+            current_section = line.strip()[3:]
+            current_content = [line]
+        elif current_section:
+            current_content.append(line)
 
-    # Don't generate a default description, leave empty if none found
-    default_description = ""
-    description, filtered_content = extract_description_and_filter_content(
-        content_lines, default_description
-    )
+    if current_section:
+        sections[current_section] = current_content
 
-    with open(filepath, "w") as f:
-        # Only add frontmatter if description is not empty
-        if description:
-            frontmatter = f"""---
-description: {description}
----
-"""
-            f.write(frontmatter)
+    return sections
 
-        for line in filtered_content:
-            f.write(line)
 
+def process_command_section(
+    section_name: str,
+    section_content: list[str],
+    agents: list[BaseAgent],
+    dirs: dict[str, Path],
+) -> bool:
+    """Process a section as a command for all agents."""
+    if not any(line.strip() for line in section_content):
+        return False
 
-def write_github_prompt(content_lines, filename, prompts_dir, section_name=None):
-    """Write a GitHub prompt file with proper frontmatter."""
-    filepath = os.path.join(prompts_dir, filename + ".prompt.md")
+    filename = header_to_filename(section_name)
+    section_content = replace_header_with_proper_casing(section_content, section_name)
 
-    # Don't generate a default description, leave empty if none found
-    default_description = ""
-    description, filtered_content = extract_description_and_filter_content(
-        content_lines, default_description
-    )
+    for agent in agents:
+        if agent.commands_dir:
+            agent.write_command(
+                section_content, filename, dirs[agent.name], section_name
+            )
 
-    frontmatter = f"""---
-mode: 'agent'
-description: '{description}'
----
-"""
+    return True
 
-    with open(filepath, "w") as f:
-        f.write(frontmatter)
-        for line in filtered_content:
-            f.write(line)
 
+def process_unmapped_as_always_apply(
+    section_name: str,
+    section_content: list[str],
+    cursor_agent,
+    github_agent,
+    cursor_rules_dir: Path,
+    copilot_dir: Path,
+) -> bool:
+    """Process an unmapped section as an always-apply rule."""
+    if not any(line.strip() for line in section_content):
+        return False
 
-def process_unmapped_section(lines, section_name, rules_dir, github_prompts_dir):
-    """Process an unmapped section as a manually applied rule (prompt)."""
-    section_content = extract_section(lines, f"## {section_name}")
-    if any(line.strip() for line in section_content):
-        filename = header_to_filename(section_name)
+    filename = header_to_filename(section_name)
+    section_content = replace_header_with_proper_casing(section_content, section_name)
 
-        # Replace header with proper casing
-        section_content = replace_header_with_proper_casing(
-            section_content, section_name
-        )
+    cursor_agent.write_rule(
+        section_content, filename, cursor_rules_dir, glob_pattern=None
+    )
+    github_agent.write_rule(section_content, filename, copilot_dir, glob_pattern=None)
 
-        # Create prompt files (same as None case in SECTION_GLOBS)
-        write_cursor_prompt(section_content, filename, rules_dir, section_name)
-        write_github_prompt(section_content, filename, github_prompts_dir, section_name)
-        return True
-    return False
+    return True
 
 
 def explode_main(
     input_file: Annotated[
         str, typer.Argument(help="Input markdown file")
     ] = "instructions.md",
-    verbose: Annotated[
-        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
-    ] = False,
     config: Annotated[
-        str, typer.Option("--config", "-c", help="Custom configuration file path")
+        str | None,
+        typer.Option("--config", "-c", help="Custom configuration file path"),
     ] = None,
-):
+    agent: Annotated[
+        str,
+        typer.Option(
+            "--agent",
+            "-a",
+            help="Agent to explode for (cursor, github, claude, gemini, or all)",
+        ),
+    ] = "all",
+) -> None:
     """Convert instruction file to separate rule files."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
 
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
+    if agent not in VALID_AGENTS:
+        log.error("invalid agent", agent=agent, valid_agents=VALID_AGENTS)
+        error_msg = (
+            f"Invalid agent '{agent}'. Must be one of: {', '.join(VALID_AGENTS)}"
+        )
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
 
-    logger.info("Starting explode operation", input_file=input_file, config=config)
+    section_globs = load_section_globs(config)
 
-    # Work in current directory ($PWD)
-    rules_dir = os.path.join(os.getcwd(), ".cursor", "rules")
-    copilot_dir = os.path.join(os.getcwd(), ".github", "instructions")
-    github_prompts_dir = os.path.join(os.getcwd(), ".github", "prompts")
+    log.info(
+        "starting explode operation", input_file=input_file, agent=agent, config=config
+    )
 
-    os.makedirs(rules_dir, exist_ok=True)
-    os.makedirs(copilot_dir, exist_ok=True)
-    os.makedirs(github_prompts_dir, exist_ok=True)
+    cwd = Path.cwd()
 
-    input_path = os.path.join(os.getcwd(), input_file)
+    # Initialize only the agents we need
+    agents_to_process = []
+    if agent == "all":
+        agents_to_process = ["cursor", "github", "claude", "gemini", "opencode"]
+    else:
+        agents_to_process = [agent]
+
+    # Initialize agents and create directories
+    agent_instances = {}
+    agent_dirs = {}
+
+    for agent_name in agents_to_process:
+        agent_instances[agent_name] = get_agent(agent_name)
+
+        if agent_name in ["cursor", "github"]:
+            # These agents have both rules and commands
+            rules_dir = cwd / agent_instances[agent_name].rules_dir
+            commands_dir = cwd / agent_instances[agent_name].commands_dir
+            rules_dir.mkdir(parents=True, exist_ok=True)
+            commands_dir.mkdir(parents=True, exist_ok=True)
+            agent_dirs[agent_name] = {"rules": rules_dir, "commands": commands_dir}
+        else:
+            # claude, gemini, and opencode only have commands
+            commands_dir = cwd / agent_instances[agent_name].commands_dir
+            commands_dir.mkdir(parents=True, exist_ok=True)
+            agent_dirs[agent_name] = {"commands": commands_dir}
+
+    input_path = cwd / input_file
 
     try:
-        with open(input_path, "r") as f:
-            lines = f.readlines()
+        lines = input_path.read_text().splitlines(keepends=True)
     except FileNotFoundError:
-        logger.error("Input file not found", input_file=input_path)
+        log.error("input file not found", input_file=str(input_path))
+        error_msg = f"Input file not found: {input_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         raise typer.Exit(1)
 
-    # General instructions
+    commands_path = input_path.parent / "commands.md"
+    commands_lines = []
+    if commands_path.exists():
+        commands_lines = commands_path.read_text().splitlines(keepends=True)
+        log.info("found commands file", commands_file=str(commands_path))
+
+    # Process general instructions for agents that support rules
     general = extract_general(lines)
     if any(line.strip() for line in general):
         general_header = """
@@ -260,77 +199,122 @@ description:
 alwaysApply: true
 ---
 """
-        write_rule(os.path.join(rules_dir, "general.mdc"), general_header, general)
-        # Copilot general instructions (no frontmatter)
-        write_rule(
-            os.path.join(os.getcwd(), ".github", "copilot-instructions.md"), "", general
-        )
+        if "cursor" in agent_instances:
+            write_rule_file(
+                agent_dirs["cursor"]["rules"] / "general.mdc", general_header, general
+            )
+        if "github" in agent_instances:
+            agent_instances["github"].write_general_instructions(general, cwd)
 
-    # Process each section dynamically
+    # Process mapped sections for agents that support rules
     found_sections = set()
-    for section_name, glob_or_description in SECTION_GLOBS.items():
+    for section_name, glob_pattern in section_globs.items():
         section_content = extract_section(lines, f"## {section_name}")
         if any(line.strip() for line in section_content):
             found_sections.add(section_name)
             filename = header_to_filename(section_name)
 
-            # Replace header with proper casing from SECTION_GLOBS
             section_content = replace_header_with_proper_casing(
                 section_content, section_name
             )
 
-            if glob_or_description is not None:
-                # It's a glob pattern - create instruction files
-                cursor_header = generate_cursor_frontmatter(glob_or_description)
-                write_rule(
-                    os.path.join(rules_dir, filename + ".mdc"),
-                    cursor_header,
+            if "cursor" in agent_instances:
+                agent_instances["cursor"].write_rule(
                     section_content,
+                    filename,
+                    agent_dirs["cursor"]["rules"],
+                    glob_pattern,
                 )
-
-                copilot_header = generate_copilot_frontmatter(glob_or_description)
-                write_rule(
-                    os.path.join(copilot_dir, filename + ".instructions.md"),
-                    copilot_header,
+            if "github" in agent_instances:
+                agent_instances["github"].write_rule(
                     section_content,
-                )
-            else:
-                # It's a prompt - create prompt files using the original section name for header
-                write_cursor_prompt(section_content, filename, rules_dir, section_name)
-                write_github_prompt(
-                    section_content, filename, github_prompts_dir, section_name
+                    filename,
+                    agent_dirs["github"]["rules"],
+                    glob_pattern,
                 )
 
-    # Check for sections in mapping that don't exist in the file
-    for section_name in SECTION_GLOBS:
+    for section_name in section_globs:
         if section_name not in found_sections:
-            logger.warning("Section not found in file", section=section_name)
+            log.warning("section not found in file", section=section_name)
 
-    # Process unmapped sections as manually applied rules (prompts)
-    processed_unmapped = set()
-    for line in lines:
-        if line.startswith("## "):
-            section_header = line.strip()
-            section_name = section_header[3:]  # Remove "## "
-            # Case insensitive check and avoid duplicate processing
-            if (
-                not any(
+    # Process unmapped sections for agents that support rules
+    if "cursor" in agent_instances or "github" in agent_instances:
+        for line in lines:
+            if line.startswith("## "):
+                section_name = line.strip()[3:]
+                if not any(
                     section_name.lower() == mapped_section.lower()
-                    for mapped_section in SECTION_GLOBS
-                )
-                and section_name not in processed_unmapped
-            ):
-                if process_unmapped_section(
-                    lines, section_name, rules_dir, github_prompts_dir
+                    for mapped_section in section_globs
                 ):
-                    processed_unmapped.add(section_name)
-
-    logger.info(
-        "Explode operation completed",
-        cursor_rules=rules_dir,
-        copilot_instructions=copilot_dir,
-        github_prompts=github_prompts_dir,
-    )
-    typer.echo(
-        "Created Cursor rules in .cursor/rules/, Copilot instructions in .github/instructions/, and prompts in respective directories"
-    )
+                    log.warning(
+                        "unmapped section in instructions.md, treating as always-apply rule",
+                        section=section_name,
+                    )
+                    section_content = extract_section(lines, f"## {section_name}")
+
+                    if "cursor" in agent_instances and "github" in agent_instances:
+                        process_unmapped_as_always_apply(
+                            section_name,
+                            section_content,
+                            agent_instances["cursor"],
+                            agent_instances["github"],
+                            agent_dirs["cursor"]["rules"],
+                            agent_dirs["github"]["rules"],
+                        )
+                    elif "cursor" in agent_instances:
+                        # Only cursor - write just cursor rules
+                        if any(line.strip() for line in section_content):
+                            filename = header_to_filename(section_name)
+                            section_content = replace_header_with_proper_casing(
+                                section_content, section_name
+                            )
+                            agent_instances["cursor"].write_rule(
+                                section_content,
+                                filename,
+                                agent_dirs["cursor"]["rules"],
+                                glob_pattern=None,
+                            )
+                    elif "github" in agent_instances:
+                        # Only github - write just github rules
+                        if any(line.strip() for line in section_content):
+                            filename = header_to_filename(section_name)
+                            section_content = replace_header_with_proper_casing(
+                                section_content, section_name
+                            )
+                            agent_instances["github"].write_rule(
+                                section_content,
+                                filename,
+                                agent_dirs["github"]["rules"],
+                                glob_pattern=None,
+                            )
+
+    # Process commands for all agents
+    if commands_lines:
+        command_sections = extract_all_sections(commands_lines)
+        agents = [agent_instances[name] for name in agents_to_process]
+        command_dirs = {
+            name: agent_dirs[name]["commands"] for name in agents_to_process
+        }
+
+        for section_name, section_content in command_sections.items():
+            process_command_section(section_name, section_content, agents, command_dirs)
+
+    # Build log message and user output based on processed agents
+    log_data = {"agent": agent}
+    created_dirs = []
+
+    for agent_name in agents_to_process:
+        if agent_name in ["cursor", "github"]:
+            log_data[f"{agent_name}_rules"] = str(agent_dirs[agent_name]["rules"])
+            log_data[f"{agent_name}_commands"] = str(agent_dirs[agent_name]["commands"])
+            created_dirs.append(f".{agent_name}/")
+        else:
+            log_data[f"{agent_name}_commands"] = str(agent_dirs[agent_name]["commands"])
+            created_dirs.append(f".{agent_name}/")
+
+    if len(created_dirs) == 1:
+        success_msg = f"Created files in {created_dirs[0]} directory"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        success_msg = f"Created files in {', '.join(created_dirs)} directories"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))