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

llm_ide_rules/commands/explode.py

@@ -1,428 +1,268 @@
 """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
-
-logger = structlog.get_logger()
+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 header_to_filename, VALID_AGENTS
+from llm_ide_rules.markdown_parser import parse_sections
+
+
+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
+
+    filename = header_to_filename(section_name)
+    section_content = replace_header_with_proper_casing(section_content, section_name)
+
+    for agent in agents:
+        if agent.commands_dir:
+            agent.write_command(
+                section_content, filename, dirs[agent.name], section_name
+            )
 
+    return True
 
-def generate_cursor_frontmatter(glob):
-    """Generate Cursor rule frontmatter for a given glob pattern."""
-    return f"""---
-description:
-globs: {glob}
-alwaysApply: false
----
-"""
 
+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 generate_copilot_frontmatter(glob):
-    """Generate Copilot instruction frontmatter for a given glob pattern."""
-    return f"""---
-applyTo: "{glob}"
----
-"""
+    filename = header_to_filename(section_name)
+    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)
 
-def extract_general(lines):
-    """
-    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.
-    Includes the header itself in the output.
-    """
-    content = []
-    in_section = False
-    for line in lines:
-        if in_section:
-            if line.startswith("## "):
-                break
-            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
-
-    return content_lines[start:end]
-
-
-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
-
-    # Find and replace the first header line
-    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, 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 True
 
-    return description, filtered_content
 
+def explode_implementation(
+    input_file: str = "instructions.md",
+    agent: str = "all",
+    working_dir: Path | None = None,
+) -> None:
+    """Core implementation of explode command."""
+    if working_dir is None:
+        working_dir = Path.cwd()
 
-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")
+    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)
 
-    # 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
+    log.info(
+        "starting explode operation",
+        input_file=input_file,
+        agent=agent,
+        working_dir=str(working_dir),
     )
 
-    with open(filepath, "w") as f:
-        # Only add frontmatter if description is not empty
-        if description:
-            frontmatter = f"""---
-description: {description}
----
-"""
-            f.write(frontmatter)
+    # 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 = working_dir / agent_instances[agent_name].rules_dir
+            commands_dir = working_dir / 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 = working_dir / agent_instances[agent_name].commands_dir
+            commands_dir.mkdir(parents=True, exist_ok=True)
+            agent_dirs[agent_name] = {"commands": commands_dir}
 
-        for line in filtered_content:
-            f.write(line)
+    input_path = working_dir / input_file
 
+    try:
+        input_text = input_path.read_text()
+    except FileNotFoundError:
+        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)
 
-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")
+    commands_path = input_path.parent / "commands.md"
+    commands_text = ""
+    if commands_path.exists():
+        commands_text = commands_path.read_text()
+        log.info("found commands file", commands_file=str(commands_path))
 
-    # 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
-    )
+    # Parse instructions
+    general, instruction_sections = parse_sections(input_text)
 
-    frontmatter = f"""---
-mode: 'agent'
-description: '{description}'
+    # Process general instructions for agents that support rules
+    if any(line.strip() for line in general):
+        general_header = """
+---
+description:
+alwaysApply: true
 ---
 """
+        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, working_dir)
 
-    with open(filepath, "w") as f:
-        f.write(frontmatter)
-        for line in filtered_content:
-            f.write(line)
-
-
-def write_cursor_command(content_lines, filename, commands_dir, section_name=None):
-    """Write a Cursor command file (plain markdown, no frontmatter)."""
-    filepath = os.path.join(commands_dir, filename + ".md")
-
-    trimmed = trim_content(content_lines)
-
-    # Strip the header from content (first line starting with ##)
-    filtered_content = []
-    found_header = False
-    for line in trimmed:
-        if not found_header and line.startswith("## "):
-            found_header = True
-            continue
-        filtered_content.append(line)
-
-    # Trim again after removing header
-    filtered_content = trim_content(filtered_content)
-
-    with open(filepath, "w") as f:
-        for line in filtered_content:
-            f.write(line)
-
-
-def write_claude_command(content_lines, filename, commands_dir, section_name=None):
-    """Write a Claude Code command file (plain markdown, no frontmatter)."""
-    filepath = os.path.join(commands_dir, filename + ".md")
+    # Process sections for agents that support rules
+    rules_sections: dict[str, list[str]] = {}
+    section_globs: dict[str, str | None] = {}
 
-    trimmed = trim_content(content_lines)
+    for section_name, section_data in instruction_sections.items():
+        content = section_data.content
+        glob_pattern = section_data.glob_pattern
 
-    # Strip the header from content (first line starting with ##)
-    filtered_content = []
-    found_header = False
-    for line in trimmed:
-        if not found_header and line.startswith("## "):
-            found_header = True
+        if not any(line.strip() for line in content):
             continue
-        filtered_content.append(line)
-
-    # Trim again after removing header
-    filtered_content = trim_content(filtered_content)
 
-    with open(filepath, "w") as f:
-        for line in filtered_content:
-            f.write(line)
+        rules_sections[section_name] = content
+        section_globs[section_name] = glob_pattern
+        filename = header_to_filename(section_name)
 
+        section_content = replace_header_with_proper_casing(content, section_name)
 
-def write_gemini_command(content_lines, filename, commands_dir, section_name=None):
-    """Write a Gemini CLI command file (TOML format)."""
-    filepath = os.path.join(commands_dir, filename + ".toml")
+        if glob_pattern is None:
+            # No directive = alwaysApply
+            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:
+                agent_instances["cursor"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["cursor"]["rules"],
+                    glob_pattern=None,
+                )
+            elif "github" in agent_instances:
+                agent_instances["github"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["github"]["rules"],
+                    glob_pattern=None,
+                )
+        elif glob_pattern != "manual":
+            # Has glob pattern = file-specific rule
+            if "cursor" in agent_instances:
+                agent_instances["cursor"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["cursor"]["rules"],
+                    glob_pattern,
+                )
+            if "github" in agent_instances:
+                agent_instances["github"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["github"]["rules"],
+                    glob_pattern,
+                )
 
-    description, filtered_content = extract_description_and_filter_content(
-        content_lines, ""
-    )
+    # Process commands for all agents
+    command_sections_data = {}
+    command_sections = {}
+    if commands_text:
+        _, command_sections_data = parse_sections(commands_text)
+        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_data in command_sections_data.items():
+            command_sections[section_name] = section_data.content
+            process_command_section(
+                section_name, section_data.content, agents, command_dirs
+            )
 
-    # Strip the header from content (first line starting with ##)
-    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)
+    # Generate root documentation (CLAUDE.md, GEMINI.md, etc.)
+    for agent_name, agent_inst in agent_instances.items():
+        agent_inst.generate_root_doc(
+            general,
+            rules_sections,
+            command_sections,
+            working_dir,
+        )
 
-    # Trim and convert to string
-    final_content = trim_content(final_content)
-    content_str = "".join(final_content).strip()
+    # Build log message and user output based on processed agents
+    log_data = {"agent": agent}
+    created_dirs = []
 
-    with open(filepath, "w") as f:
-        f.write(f'name = "{filename}"\n')
-        if description:
-            f.write(f'description = "{description}"\n')
+    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:
-            f.write(f'description = "{section_name or filename}"\n')
-        f.write('\n[command]\n')
-        f.write('shell = """\n')
-        f.write(content_str)
-        f.write('\n"""\n')
-
-
-def process_unmapped_section(lines, section_name, cursor_commands_dir, github_prompts_dir, claude_commands_dir, gemini_commands_dir):
-    """Process an unmapped section as a manually applied rule (command)."""
-    section_content = extract_section(lines, f"## {section_name}")
-    if any(line.strip() for line in section_content):
-        filename = header_to_filename(section_name)
-
-        # Replace header with proper casing
-        section_content = replace_header_with_proper_casing(
-            section_content, section_name
-        )
+            log_data[f"{agent_name}_commands"] = str(agent_dirs[agent_name]["commands"])
+            created_dirs.append(f".{agent_name}/")
 
-        # Create command files (same as None case in SECTION_GLOBS)
-        write_cursor_command(section_content, filename, cursor_commands_dir, section_name)
-        write_github_prompt(section_content, filename, github_prompts_dir, section_name)
-        write_claude_command(section_content, filename, claude_commands_dir, section_name)
-        write_gemini_command(section_content, filename, gemini_commands_dir, section_name)
-        return True
-    return False
+    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))
 
 
 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")
-    ] = 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)
-
-    logger.info("Starting explode operation", input_file=input_file, config=config)
-
-    # Work in current directory ($PWD)
-    rules_dir = os.path.join(os.getcwd(), ".cursor", "rules")
-    cursor_commands_dir = os.path.join(os.getcwd(), ".cursor", "commands")
-    copilot_dir = os.path.join(os.getcwd(), ".github", "instructions")
-    github_prompts_dir = os.path.join(os.getcwd(), ".github", "prompts")
-    claude_commands_dir = os.path.join(os.getcwd(), ".claude", "commands")
-    gemini_commands_dir = os.path.join(os.getcwd(), ".gemini", "commands")
-
-    os.makedirs(rules_dir, exist_ok=True)
-    os.makedirs(cursor_commands_dir, exist_ok=True)
-    os.makedirs(copilot_dir, exist_ok=True)
-    os.makedirs(github_prompts_dir, exist_ok=True)
-    os.makedirs(claude_commands_dir, exist_ok=True)
-    os.makedirs(gemini_commands_dir, exist_ok=True)
-
-    input_path = os.path.join(os.getcwd(), input_file)
-
-    try:
-        with open(input_path, "r") as f:
-            lines = f.readlines()
-    except FileNotFoundError:
-        logger.error("Input file not found", input_file=input_path)
-        raise typer.Exit(1)
-
-    # General instructions
-    general = extract_general(lines)
-    if any(line.strip() for line in general):
-        general_header = """
----
-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
-        )
-
-    # Process each section dynamically
-    found_sections = set()
-    for section_name, glob_or_description 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,
-                    section_content,
-                )
-
-                copilot_header = generate_copilot_frontmatter(glob_or_description)
-                write_rule(
-                    os.path.join(copilot_dir, filename + ".instructions.md"),
-                    copilot_header,
-                    section_content,
-                )
-            else:
-                # It's a command - create command files using the original section name for header
-                write_cursor_command(section_content, filename, cursor_commands_dir, section_name)
-                write_github_prompt(
-                    section_content, filename, github_prompts_dir, section_name
-                )
-                write_claude_command(section_content, filename, claude_commands_dir, section_name)
-                write_gemini_command(section_content, filename, gemini_commands_dir, section_name)
-
-    # Check for sections in mapping that don't exist in the file
-    for section_name in SECTION_GLOBS:
-        if section_name not in found_sections:
-            logger.warning("Section not found in file", section=section_name)
-
-    # Process unmapped sections as manually applied rules (commands)
-    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(
-                    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, cursor_commands_dir, github_prompts_dir, claude_commands_dir, gemini_commands_dir
-                ):
-                    processed_unmapped.add(section_name)
-
-    logger.info(
-        "Explode operation completed",
-        cursor_rules=rules_dir,
-        cursor_commands=cursor_commands_dir,
-        copilot_instructions=copilot_dir,
-        github_prompts=github_prompts_dir,
-        claude_commands=claude_commands_dir,
-        gemini_commands=gemini_commands_dir,
-    )
-    typer.echo(
-        "Created rules and commands in .cursor/, .claude/, .github/, and .gemini/ directories"
-    )
+    explode_implementation(input_file, agent, Path.cwd())