llm-ide-rules 0.3.0__tar.gz → 0.5.0__tar.gz

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llm-ide-rules
-Version: 0.3.0
+Version: 0.5.0
 Summary: CLI tool for managing LLM IDE prompts and rules
 Keywords: llm,ide,prompts,cursor,copilot
 Author: Michael Bianco
@@ -62,6 +62,10 @@ uvx llm-ide-rules download [instruction_types]    # Download everything by defau
 uvx llm-ide-rules download cursor github          # Download specific types
 uvx llm-ide-rules download --repo other/repo      # Download from different repo
 
+# Delete downloaded instruction files
+uvx llm-ide-rules delete [instruction_types]      # Delete everything by default
+uvx llm-ide-rules delete cursor gemini            # Delete specific types
+uvx llm-ide-rules delete --yes                    # Skip confirmation prompt
 
 ```
 
@@ -85,8 +89,28 @@ uvx llm-ide-rules download cursor github
 
 # Download from a different repository
 uvx llm-ide-rules download --repo other-user/other-repo --target ./my-project
+
+# Delete all downloaded files (with confirmation)
+uvx llm-ide-rules delete
+
+# Delete specific instruction types
+uvx llm-ide-rules delete cursor gemini --target ./my-project
+
+# Delete without confirmation prompt
+uvx llm-ide-rules delete --yes
 ```
 
+### IDE Command Format Comparison
+
+Different AI coding assistants use different formats for commands:
+
+| IDE | Directory | Format | Notes |
+|-----|-----------|--------|-------|
+| **Cursor** | `.cursor/commands/` | `.md` (plain markdown) | Simple, no frontmatter |
+| **Claude Code** | `.claude/commands/` | `.md` (plain markdown) | Simple, no frontmatter |
+| **GitHub Copilot** | `.github/prompts/` | `.prompt.md` (YAML + markdown) | Requires frontmatter with `mode: 'agent'` |
+| **Gemini CLI** | `.gemini/commands/` | `.toml` | Uses TOML format, supports `{{args}}` and shell commands |
+
 ## Development
 
 ### Using the CLI for Development

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/README.md

@@ -48,6 +48,10 @@ uvx llm-ide-rules download [instruction_types]    # Download everything by defau
 uvx llm-ide-rules download cursor github          # Download specific types
 uvx llm-ide-rules download --repo other/repo      # Download from different repo
 
+# Delete downloaded instruction files
+uvx llm-ide-rules delete [instruction_types]      # Delete everything by default
+uvx llm-ide-rules delete cursor gemini            # Delete specific types
+uvx llm-ide-rules delete --yes                    # Skip confirmation prompt
 
 ```
 
@@ -71,8 +75,28 @@ uvx llm-ide-rules download cursor github
 
 # Download from a different repository
 uvx llm-ide-rules download --repo other-user/other-repo --target ./my-project
+
+# Delete all downloaded files (with confirmation)
+uvx llm-ide-rules delete
+
+# Delete specific instruction types
+uvx llm-ide-rules delete cursor gemini --target ./my-project
+
+# Delete without confirmation prompt
+uvx llm-ide-rules delete --yes
 ```
 
+### IDE Command Format Comparison
+
+Different AI coding assistants use different formats for commands:
+
+| IDE | Directory | Format | Notes |
+|-----|-----------|--------|-------|
+| **Cursor** | `.cursor/commands/` | `.md` (plain markdown) | Simple, no frontmatter |
+| **Claude Code** | `.claude/commands/` | `.md` (plain markdown) | Simple, no frontmatter |
+| **GitHub Copilot** | `.github/prompts/` | `.prompt.md` (YAML + markdown) | Requires frontmatter with `mode: 'agent'` |
+| **Gemini CLI** | `.gemini/commands/` | `.toml` | Uses TOML format, supports `{{args}}` and shell commands |
+
 ## Development
 
 ### Using the CLI for Development

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llm-ide-rules"
-version = "0.3.0"
+version = "0.5.0"
 description = "CLI tool for managing LLM IDE prompts and rules"
 keywords = ["llm", "ide", "prompts", "cursor", "copilot"]
 readme = "README.md"

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/src/llm_ide_rules/__init__.py

@@ -4,10 +4,11 @@ import typer
 from typing_extensions import Annotated
 
 from llm_ide_rules.commands.explode import explode_main
-from llm_ide_rules.commands.implode import cursor, github
+from llm_ide_rules.commands.implode import cursor, github, claude, gemini
 from llm_ide_rules.commands.download import download_main
+from llm_ide_rules.commands.delete import delete_main
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
 app = typer.Typer(
     name="llm_ide_rules",
@@ -18,11 +19,14 @@ app = typer.Typer(
 # Add commands directly
 app.command("explode", help="Convert instruction file to separate rule files")(explode_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)
 
 # 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 into a single file")(cursor)
-implode_app.command("github", help="Bundle GitHub/Copilot instructions into a single file")(github)
+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 commands into a single file")(claude)
+implode_app.command("gemini", help="Bundle Gemini CLI commands into a single file")(gemini)
 app.add_typer(implode_app, name="implode")
 
 def main():

llm_ide_rules-0.5.0/src/llm_ide_rules/commands/delete.py

@@ -0,0 +1,179 @@
+"""Delete command: Remove downloaded LLM instruction files."""
+
+import logging
+import shutil
+from pathlib import Path
+from typing import List
+
+import structlog
+import typer
+from typing_extensions import Annotated
+
+from llm_ide_rules.commands.download import INSTRUCTION_TYPES, DEFAULT_TYPES
+
+logger = structlog.get_logger()
+
+
+def find_files_to_delete(
+    instruction_types: List[str], target_dir: Path
+) -> tuple[List[Path], List[Path]]:
+    """Find all files and directories that would be deleted.
+    
+    Returns:
+        Tuple of (directories, files) to delete
+    """
+    dirs_to_delete = []
+    files_to_delete = []
+
+    for inst_type in instruction_types:
+        if inst_type not in INSTRUCTION_TYPES:
+            logger.warning("Unknown instruction type", type=inst_type)
+            continue
+
+        config = INSTRUCTION_TYPES[inst_type]
+
+        for dir_name in config["directories"]:
+            dir_path = target_dir / dir_name
+            if dir_path.exists() and dir_path.is_dir():
+                dirs_to_delete.append(dir_path)
+
+        for file_name in config["files"]:
+            file_path = target_dir / file_name
+            if file_path.exists() and file_path.is_file():
+                files_to_delete.append(file_path)
+
+        for file_pattern in config.get("recursive_files", []):
+            matching_files = list(target_dir.rglob(file_pattern))
+            files_to_delete.extend([f for f in matching_files if f.is_file()])
+
+    return dirs_to_delete, files_to_delete
+
+
+def delete_main(
+    instruction_types: Annotated[
+        List[str],
+        typer.Argument(
+            help="Types of instructions to delete (cursor, github, gemini, claude, agent, agents). Deletes everything by default."
+        ),
+    ] = None,
+    target_dir: Annotated[
+        str, typer.Option("--target", "-t", help="Target directory to delete from")
+    ] = ".",
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip confirmation prompt and delete immediately"),
+    ] = False,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
+    ] = False,
+):
+    """Remove downloaded LLM instruction files.
+
+    This command removes files and directories that were downloaded by the 'download' command.
+    It will show you what will be deleted and ask for confirmation before proceeding.
+
+    Examples:
+
+    \b
+    # Delete everything (with confirmation)
+    llm_ide_rules delete
+
+    \b
+    # Delete only Cursor and Gemini files
+    llm_ide_rules delete cursor gemini
+
+    \b
+    # Delete without confirmation prompt
+    llm_ide_rules delete --yes
+
+    \b
+    # Delete from a specific directory
+    llm_ide_rules delete --target ./my-project
+    """
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG)
+        structlog.configure(
+            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+        )
+
+    if not instruction_types:
+        instruction_types = DEFAULT_TYPES
+
+    invalid_types = [t for t in instruction_types if t not in INSTRUCTION_TYPES]
+    if invalid_types:
+        logger.error(
+            "Invalid instruction types",
+            invalid_types=invalid_types,
+            valid_types=list(INSTRUCTION_TYPES.keys()),
+        )
+        raise typer.Exit(1)
+
+    target_path = Path(target_dir).resolve()
+
+    if not target_path.exists():
+        logger.error("Target directory does not exist", target_dir=str(target_path))
+        typer.echo(f"Error: Target directory does not exist: {target_path}")
+        raise typer.Exit(1)
+
+    logger.info(
+        "Finding files to delete",
+        instruction_types=instruction_types,
+        target_dir=str(target_path),
+    )
+
+    dirs_to_delete, files_to_delete = find_files_to_delete(
+        instruction_types, target_path
+    )
+
+    if not dirs_to_delete and not files_to_delete:
+        logger.info("No files found to delete")
+        typer.echo("No matching instruction files found to delete.")
+        return
+
+    typer.echo("\nThe following files and directories will be deleted:\n")
+
+    if dirs_to_delete:
+        typer.echo("Directories:")
+        for dir_path in sorted(dirs_to_delete):
+            relative_path = dir_path.relative_to(target_path)
+            typer.echo(f"  - {relative_path}/")
+
+    if files_to_delete:
+        typer.echo("\nFiles:")
+        for file_path in sorted(files_to_delete):
+            relative_path = file_path.relative_to(target_path)
+            typer.echo(f"  - {relative_path}")
+
+    total_items = len(dirs_to_delete) + len(files_to_delete)
+    typer.echo(f"\nTotal: {total_items} items")
+
+    if not yes:
+        typer.echo()
+        confirm = typer.confirm("Are you sure you want to delete these files?")
+        if not confirm:
+            logger.info("Deletion cancelled by user")
+            typer.echo("Deletion cancelled.")
+            raise typer.Exit(0)
+
+    deleted_count = 0
+
+    for dir_path in dirs_to_delete:
+        try:
+            logger.info("Deleting directory", path=str(dir_path))
+            shutil.rmtree(dir_path)
+            deleted_count += 1
+        except Exception as e:
+            logger.error("Failed to delete directory", path=str(dir_path), error=str(e))
+            typer.echo(f"Error deleting {dir_path}: {e}", err=True)
+
+    for file_path in files_to_delete:
+        try:
+            logger.info("Deleting file", path=str(file_path))
+            file_path.unlink()
+            deleted_count += 1
+        except Exception as e:
+            logger.error("Failed to delete file", path=str(file_path), error=str(e))
+            typer.echo(f"Error deleting {file_path}: {e}", err=True)
+
+    logger.info("Deletion completed", deleted_count=deleted_count, total_items=total_items)
+    typer.echo(f"\nSuccessfully deleted {deleted_count} of {total_items} items.")

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/src/llm_ide_rules/commands/explode.py

@@ -192,8 +192,87 @@ description: '{description}'
             f.write(line)
 
 
-def process_unmapped_section(lines, section_name, rules_dir, github_prompts_dir):
-    """Process an unmapped section as a manually applied rule (prompt)."""
+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")
+
+    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_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")
+
+    description, filtered_content = extract_description_and_filter_content(
+        content_lines, ""
+    )
+
+    # 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)
+
+    # Trim and convert to string
+    final_content = trim_content(final_content)
+    content_str = "".join(final_content).strip()
+
+    with open(filepath, "w") as f:
+        f.write(f'name = "{filename}"\n')
+        if description:
+            f.write(f'description = "{description}"\n')
+        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)
@@ -203,9 +282,11 @@ def process_unmapped_section(lines, section_name, rules_dir, github_prompts_dir)
             section_content, section_name
         )
 
-        # Create prompt files (same as None case in SECTION_GLOBS)
-        write_cursor_prompt(section_content, filename, rules_dir, section_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
 
@@ -235,12 +316,18 @@ def explode_main(
 
     # 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)
 
@@ -295,18 +382,20 @@ alwaysApply: true
                     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)
+                # 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 (prompts)
+    # Process unmapped sections as manually applied rules (commands)
     processed_unmapped = set()
     for line in lines:
         if line.startswith("## "):
@@ -321,16 +410,19 @@ alwaysApply: true
                 and section_name not in processed_unmapped
             ):
                 if process_unmapped_section(
-                    lines, section_name, rules_dir, github_prompts_dir
+                    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 Cursor rules in .cursor/rules/, Copilot instructions in .github/instructions/, and prompts in respective directories"
+        "Created rules and commands in .cursor/, .claude/, .github/, and .gemini/ directories"
     )

llm_ide_rules-0.5.0/src/llm_ide_rules/commands/implode.py

@@ -0,0 +1,400 @@
+"""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")
+
+
+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),
+        )
+
+    # Load section globs (with optional custom config)
+    SECTION_GLOBS = load_section_globs(config)
+
+    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)
+
+    logger.info("Bundling Cursor rules and commands", rules_dir=rules_dir, commands_dir=commands_dir, output_file=output_path, config=config)
+
+    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")] = "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),
+        )
+
+    # Load section globs (with optional custom config)
+    SECTION_GLOBS = load_section_globs(config)
+
+    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)
+
+    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)
+
+    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}")
+
+
+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),
+        )
+
+    # Load section globs (with optional custom config)
+    SECTION_GLOBS = load_section_globs(config)
+
+    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)
+
+    if not Path(commands_dir).exists():
+        logger.error("Claude Code commands directory not found", commands_dir=commands_dir)
+        raise typer.Exit(1)
+
+    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}")
+
+
+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),
+        )
+
+    # 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)
+
+    logger.info("Bundling Gemini CLI commands", commands_dir=commands_dir, output_file=output_path, config=config)
+
+    if not Path(commands_dir).exists():
+        logger.error("Gemini CLI commands directory not found", commands_dir=commands_dir)
+        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}")
+

{llm_ide_rules-0.3.0 → llm_ide_rules-0.5.0}/src/llm_ide_rules/sections.json

@@ -13,6 +13,15 @@
     "Shell": "**/*.sh",
     "TypeScript": "**/*.ts,**/*.tsx",
     "TypeScript DocString": null,
-    "Secrets": null
+    "Secrets": null,
+    "Dev In Browser": null,
+    "Fastapi Stripe": null,
+    "Fix Tests": null,
+    "Implement Fastapi Routes": null,
+    "Plan Only": null,
+    "Python Command": null,
+    "Refactor On Instructions": null,
+    "Standalone Python Scripts": null,
+    "Stripe Backend": null
   }
 }

llm_ide_rules-0.3.0/src/llm_ide_rules/commands/implode.py

@@ -1,218 +0,0 @@
-"""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, output_file, section_globs):
-    """Bundle Cursor rule files into a single file."""
-    rule_files = list(Path(rules_dir).glob("*.mdc"))
-    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 = general + ordered_others
-
-    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, output_file, section_globs):
-    """Bundle GitHub instruction files into a single file."""
-    copilot_general = Path(os.getcwd()) / ".github" / "copilot-instructions.md"
-    instr_files = list(Path(instructions_dir).glob("*.instructions.md"))
-
-    # Order the instruction files based on section_globs
-    # We need to create a modified version that strips .instructions from stems for ordering
-    ordered_files = get_ordered_files_github(instr_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:
-        # 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_files:
-            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")
-
-
-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 into a single file."""
-    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)
-    
-    rules_dir = os.path.join(os.getcwd(), ".cursor", "rules")
-    output_path = os.path.join(os.getcwd(), output)
-    
-    logger.info("Bundling Cursor rules", rules_dir=rules_dir, output_file=output_path, config=config)
-    
-    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, output_path, SECTION_GLOBS)
-    logger.info("Cursor rules bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled cursor rules into {output}")
-
-
-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 into a single file."""
-    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)
-    
-    instructions_dir = os.path.join(os.getcwd(), ".github", "instructions")
-    output_path = os.path.join(os.getcwd(), output)
-    
-    logger.info("Bundling GitHub instructions", instructions_dir=instructions_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)
-    
-    bundle_github_instructions(instructions_dir, output_path, SECTION_GLOBS)
-    logger.info("GitHub instructions bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled github instructions into {output}")
-