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

llm_ide_rules/commands/implode.py

@@ -1,400 +1,214 @@
 """Implode command: Bundle rule files into a single instruction file."""
 
-import os
 from pathlib import Path
 from typing_extensions import Annotated
-import logging
 
 import typer
-import structlog
-
-from llm_ide_rules.constants import load_section_globs, header_to_filename, filename_to_header
-
-logger = structlog.get_logger()
-
-
-def get_ordered_files(file_list, section_globs_keys):
-    """Order files based on SECTION_GLOBS key order, with unmapped files at the end."""
-    file_dict = {f.stem: f for f in file_list}
-    ordered_files = []
-
-    # Add files in SECTION_GLOBS order
-    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]
-
-    # Add any remaining files (not in SECTION_GLOBS) sorted alphabetically
-    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, section_globs_keys):
-    """Order GitHub instruction files based on SECTION_GLOBS key order, with unmapped files at the end.
-    Handles .instructions suffix by stripping it for ordering purposes."""
-    # Create dict mapping base filename (without .instructions) to the actual file
-    file_dict = {}
-    for f in file_list:
-        base_stem = f.stem.replace(".instructions", "")
-        file_dict[base_stem] = f
-
-    ordered_files = []
-
-    # Add files in SECTION_GLOBS order
-    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]
-
-    # Add any remaining files (not in SECTION_GLOBS) sorted alphabetically
-    remaining_files = sorted(file_dict.values(), key=lambda p: p.name)
-    ordered_files.extend(remaining_files)
-
-    return ordered_files
-
-
-def bundle_cursor_rules(rules_dir, commands_dir, output_file, section_globs):
-    """Bundle Cursor rule and command files into a single file."""
-    rule_files = list(Path(rules_dir).glob("*.mdc"))
-    command_files = list(Path(commands_dir).glob("*.md"))
-
-    general = [f for f in rule_files if f.stem == "general"]
-    others = [f for f in rule_files if f.stem != "general"]
-
-    # Order the non-general files based on section_globs
-    ordered_others = get_ordered_files(others, section_globs.keys())
-    ordered_commands = get_ordered_files(command_files, section_globs.keys())
-    ordered = general + ordered_others + ordered_commands
-
-    def resolve_header_from_stem(stem):
-        """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.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        for rule_file in ordered:
-            with open(rule_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                content = strip_yaml_frontmatter(content)
-                content = strip_header(content)
-                # Use canonical header names from SECTION_GLOBS when available
-                header = resolve_header_from_stem(rule_file.stem)
-                if rule_file.stem != "general":
-                    out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
-
-
-def strip_yaml_frontmatter(text):
-    """Strip YAML frontmatter from text."""
-    lines = text.splitlines()
-    if lines and lines[0].strip() == "---":
-        # Find the next '---' after the first
-        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):
-    """Remove the first markdown header (## Header) from text if present."""
-    lines = text.splitlines()
-    if lines and lines[0].startswith("## "):
-        # Remove the header line and any immediately following empty lines
-        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 bundle_github_instructions(instructions_dir, prompts_dir, output_file, section_globs):
-    """Bundle GitHub instruction and prompt files into a single file."""
-    copilot_general = Path(os.getcwd()) / ".github" / "copilot-instructions.md"
-    instr_files = list(Path(instructions_dir).glob("*.instructions.md"))
-    prompt_files = list(Path(prompts_dir).glob("*.prompt.md"))
-
-    # Order the instruction files based on section_globs
-    # We need to create a modified version that strips .instructions from stems for ordering
-    ordered_instructions = get_ordered_files_github(instr_files, section_globs.keys())
-
-    # For prompts, we need to handle .prompt suffix similarly
-    ordered_prompts = []
-    prompt_dict = {}
-    for f in prompt_files:
-        base_stem = f.stem.replace(".prompt", "")
-        prompt_dict[base_stem] = f
-
-    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]
-
-    # Add remaining prompts alphabetically
-    remaining_prompts = sorted(prompt_dict.values(), key=lambda p: p.name)
-    ordered_prompts.extend(remaining_prompts)
-
-    def resolve_header_from_stem(stem):
-        """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.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        # Write general copilot instructions if present
-        if copilot_general.exists():
-            content = copilot_general.read_text().strip()
-            if content:
-                out.write(content)
-                out.write("\n\n")
-        for instr_file in ordered_instructions:
-            with open(instr_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                content = strip_yaml_frontmatter(content)
-                content = strip_header(content)
-                # Use canonical header names from SECTION_GLOBS when available
-                base_stem = instr_file.stem.replace(".instructions", "")
-                header = resolve_header_from_stem(base_stem)
-                out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
-        for prompt_file in ordered_prompts:
-            with open(prompt_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                content = strip_yaml_frontmatter(content)
-                content = strip_header(content)
-                # Use canonical header names from SECTION_GLOBS when available
-                base_stem = prompt_file.stem.replace(".prompt", "")
-                header = resolve_header_from_stem(base_stem)
-                out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
-
-
-def bundle_claude_commands(commands_dir, output_file, section_globs):
-    """Bundle Claude Code command files into a single file."""
-    command_files = list(Path(commands_dir).glob("*.md"))
-    ordered_commands = get_ordered_files(command_files, section_globs.keys())
-
-    def resolve_header_from_stem(stem):
-        """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.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        for command_file in ordered_commands:
-            with open(command_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                # Claude commands don't have frontmatter, just content
-                header = resolve_header_from_stem(command_file.stem)
-                out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
-
-
-def strip_toml_metadata(text):
-    """Extract content from TOML command.shell block."""
-    lines = text.splitlines()
-    in_shell_block = False
-    content_lines = []
-
-    for line in lines:
-        if line.strip() == '[command]':
-            in_shell_block = True
-            continue
-        if in_shell_block:
-            if line.strip().startswith('shell = """'):
-                # Start of shell content
-                # Check if content is on same line
-                after_start = line.split('"""', 1)[1] if '"""' in line else ""
-                if after_start.strip():
-                    content_lines.append(after_start)
-                continue
-            if line.strip() == '"""' or line.strip().endswith('"""'):
-                # End of shell content
-                if line.strip() != '"""':
-                    # Content on same line as closing
-                    content_lines.append(line.rsplit('"""', 1)[0])
-                break
-            content_lines.append(line)
-
-    return "\n".join(content_lines).strip()
-
-
-def bundle_gemini_commands(commands_dir, output_file, section_globs):
-    """Bundle Gemini CLI command files into a single file."""
-    command_files = list(Path(commands_dir).glob("*.toml"))
-    ordered_commands = get_ordered_files(command_files, section_globs.keys())
-
-    def resolve_header_from_stem(stem):
-        """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.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        for command_file in ordered_commands:
-            with open(command_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                # Extract content from TOML shell block
-                content = strip_toml_metadata(content)
-                header = resolve_header_from_stem(command_file.stem)
-                out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
+
+from llm_ide_rules.agents import get_agent
+from llm_ide_rules.log import log
 
 
 def cursor(
-    output: Annotated[str, typer.Argument(help="Output 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,
-):
-    """Bundle Cursor rules and commands into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
+    output: Annotated[
+        str, typer.Argument(help="Output file for rules")
+    ] = "instructions.md",
+) -> None:
+    """Bundle Cursor rules into instructions.md and commands into commands.md."""
+
+    agent = get_agent("cursor")
+    cwd = Path.cwd()
+
+    rules_dir = agent.rules_dir
+    if not rules_dir:
+        log.error("cursor rules directory not configured")
+        raise typer.Exit(1)
 
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
+    log.info(
+        "bundling cursor rules and commands",
+        rules_dir=rules_dir,
+        commands_dir=agent.commands_dir,
+    )
+
+    rules_path = cwd / rules_dir
+    if not rules_path.exists():
+        log.error("cursor rules directory not found", rules_dir=str(rules_path))
+        error_msg = f"Cursor rules directory not found: {rules_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
 
-    rules_dir = os.path.join(os.getcwd(), ".cursor", "rules")
-    commands_dir = os.path.join(os.getcwd(), ".cursor", "commands")
-    output_path = os.path.join(os.getcwd(), output)
+    output_path = cwd / output
+    rules_written = agent.bundle_rules(output_path)
+    if rules_written:
+        success_msg = f"Bundled cursor rules into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no cursor rules to bundle")
 
-    logger.info("Bundling Cursor rules and commands", rules_dir=rules_dir, commands_dir=commands_dir, output_file=output_path, config=config)
+    commands_output_path = cwd / "commands.md"
+    commands_written = agent.bundle_commands(commands_output_path)
+    if commands_written:
+        success_msg = "Bundled cursor commands into commands.md"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        commands_output_path.unlink(missing_ok=True)
 
-    if not Path(rules_dir).exists():
-        logger.error("Cursor rules directory not found", rules_dir=rules_dir)
-        raise typer.Exit(1)
 
-    bundle_cursor_rules(rules_dir, commands_dir, output_path, SECTION_GLOBS)
-    logger.info("Cursor rules and commands bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled cursor rules and commands into {output}")
+def github(
+    output: Annotated[
+        str, typer.Argument(help="Output file for instructions")
+    ] = "instructions.md",
+) -> None:
+    """Bundle GitHub instructions into instructions.md and prompts into commands.md."""
+
+    agent = get_agent("github")
+    cwd = Path.cwd()
+
+    rules_dir = agent.rules_dir
+    if not rules_dir:
+        log.error("github rules directory not configured")
+        raise typer.Exit(1)
 
+    log.info(
+        "bundling github instructions and prompts",
+        instructions_dir=rules_dir,
+        prompts_dir=agent.commands_dir,
+    )
 
-def github(
-    output: Annotated[str, typer.Argument(help="Output 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,
-):
-    """Bundle GitHub/Copilot instructions and prompts into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+    rules_path = cwd / rules_dir
+    if not rules_path.exists():
+        log.error(
+            "github instructions directory not found", instructions_dir=str(rules_path)
         )
+        error_msg = f"GitHub instructions directory not found: {rules_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
 
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
+    output_path = cwd / output
+    instructions_written = agent.bundle_rules(output_path)
+    if instructions_written:
+        success_msg = f"Bundled github instructions into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no github instructions to bundle")
 
-    instructions_dir = os.path.join(os.getcwd(), ".github", "instructions")
-    prompts_dir = os.path.join(os.getcwd(), ".github", "prompts")
-    output_path = os.path.join(os.getcwd(), output)
+    commands_output_path = cwd / "commands.md"
+    prompts_written = agent.bundle_commands(commands_output_path)
+    if prompts_written:
+        success_msg = "Bundled github prompts into commands.md"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        commands_output_path.unlink(missing_ok=True)
 
-    logger.info("Bundling GitHub instructions and prompts", instructions_dir=instructions_dir, prompts_dir=prompts_dir, output_file=output_path, config=config)
 
-    if not Path(instructions_dir).exists():
-        logger.error("GitHub instructions directory not found", instructions_dir=instructions_dir)
-        raise typer.Exit(1)
+def claude(
+    output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
+) -> None:
+    """Bundle Claude Code commands into commands.md."""
+
+    agent = get_agent("claude")
+    cwd = Path.cwd()
 
-    bundle_github_instructions(instructions_dir, prompts_dir, output_path, SECTION_GLOBS)
-    logger.info("GitHub instructions and prompts bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled github instructions and prompts into {output}")
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("claude code commands directory not configured")
+        raise typer.Exit(1)
 
+    log.info(
+        "bundling claude code commands",
+        commands_dir=commands_dir,
+    )
 
-def claude(
-    output: Annotated[str, typer.Argument(help="Output 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,
-):
-    """Bundle Claude Code commands into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "claude code commands directory not found", commands_dir=str(commands_path)
         )
+        error_msg = f"Claude Code commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
 
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path)
+    if commands_written:
+        success_msg = f"Bundled claude commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no claude commands to bundle")
 
-    commands_dir = os.path.join(os.getcwd(), ".claude", "commands")
-    output_path = os.path.join(os.getcwd(), output)
 
-    logger.info("Bundling Claude Code commands", commands_dir=commands_dir, output_file=output_path, config=config)
+def gemini(
+    output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
+) -> None:
+    """Bundle Gemini CLI commands into commands.md."""
 
-    if not Path(commands_dir).exists():
-        logger.error("Claude Code commands directory not found", commands_dir=commands_dir)
-        raise typer.Exit(1)
+    agent = get_agent("gemini")
+    cwd = Path.cwd()
 
-    bundle_claude_commands(commands_dir, output_path, SECTION_GLOBS)
-    logger.info("Claude Code commands bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled claude commands into {output}")
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("gemini cli commands directory not configured")
+        raise typer.Exit(1)
 
+    log.info(
+        "bundling gemini cli commands",
+        commands_dir=commands_dir,
+    )
 
-def gemini(
-    output: Annotated[str, typer.Argument(help="Output 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,
-):
-    """Bundle Gemini CLI commands into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "gemini cli commands directory not found", commands_dir=str(commands_path)
         )
+        error_msg = f"Gemini CLI commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
+
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path)
+    if commands_written:
+        success_msg = f"Bundled gemini commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no gemini commands to bundle")
 
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
 
-    commands_dir = os.path.join(os.getcwd(), ".gemini", "commands")
-    output_path = os.path.join(os.getcwd(), output)
+def opencode(
+    output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
+) -> None:
+    """Bundle OpenCode commands into commands.md."""
 
-    logger.info("Bundling Gemini CLI commands", commands_dir=commands_dir, output_file=output_path, config=config)
+    agent = get_agent("opencode")
+    cwd = Path.cwd()
 
-    if not Path(commands_dir).exists():
-        logger.error("Gemini CLI commands directory not found", commands_dir=commands_dir)
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("opencode commands directory not configured")
         raise typer.Exit(1)
 
-    bundle_gemini_commands(commands_dir, output_path, SECTION_GLOBS)
-    logger.info("Gemini CLI commands bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled gemini commands into {output}")
+    log.info(
+        "bundling opencode commands",
+        commands_dir=commands_dir,
+    )
+
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "opencode commands directory not found", commands_dir=str(commands_path)
+        )
+        error_msg = f"OpenCode commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
 
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path)
+    if commands_written:
+        success_msg = f"Bundled opencode commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no opencode commands to bundle")