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

llm_ide_rules/__init__.py

@@ -0,0 +1,33 @@
+"""LLM Rules CLI package for managing IDE prompts and rules."""
+
+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.download import download_main
+
+__version__ = "0.2.0"
+
+app = typer.Typer(
+    name="llm_ide_rules",
+    help="CLI tool for managing LLM IDE prompts and rules",
+    no_args_is_help=True,
+)
+
+# 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)
+
+# 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)
+app.add_typer(implode_app, name="implode")
+
+def main():
+    """Main entry point for the CLI."""
+    app()
+
+if __name__ == "__main__":
+    main()

llm_ide_rules/__main__.py

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

llm_ide_rules/commands/download.py

@@ -0,0 +1,253 @@
+"""Download command: Download LLM instruction files from GitHub repositories."""
+
+import logging
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import List
+
+import requests
+import structlog
+import typer
+from typing_extensions import Annotated
+
+logger = structlog.get_logger()
+
+DEFAULT_REPO = "iloveitaly/llm_ide_rules"
+DEFAULT_BRANCH = "master"
+
+# Define what files/directories each instruction type includes
+INSTRUCTION_TYPES = {
+    "cursor": {"directories": [".cursor"], "files": []},
+    "github": {
+        "directories": [".github"],
+        "files": [],
+        "exclude_patterns": ["workflows/*"],
+    },
+    "gemini": {"directories": [], "files": ["GEMINI.md"]},
+    "claude": {"directories": [], "files": ["CLAUDE.md"]},
+    "agent": {"directories": [], "files": ["AGENT.md"]},
+}
+
+# Default types to download when no specific types are specified
+DEFAULT_TYPES = list(INSTRUCTION_TYPES.keys())
+
+
+def download_and_extract_repo(repo: str, branch: str = DEFAULT_BRANCH) -> Path:
+    """Download a GitHub repository as a ZIP and extract it to a temporary directory."""
+    zip_url = f"https://github.com/{repo}/archive/{branch}.zip"
+
+    logger.info("Downloading repository", repo=repo, branch=branch, url=zip_url)
+
+    try:
+        response = requests.get(zip_url, timeout=30)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        logger.error("Failed to download repository", error=str(e), url=zip_url)
+        raise typer.Exit(1)
+
+    # Create temporary directory and file
+    temp_dir = Path(tempfile.mkdtemp())
+    zip_path = temp_dir / "repo.zip"
+
+    # Write ZIP content
+    zip_path.write_bytes(response.content)
+
+    # Extract ZIP
+    extract_dir = temp_dir / "extracted"
+    extract_dir.mkdir()
+
+    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+        zip_ref.extractall(extract_dir)
+
+    # Find the extracted repository directory (should be the only directory)
+    repo_dirs = [d for d in extract_dir.iterdir() if d.is_dir()]
+    if not repo_dirs:
+        logger.error("No directories found in extracted ZIP")
+        raise typer.Exit(1)
+
+    repo_dir = repo_dirs[0]
+    logger.info("Repository extracted", path=str(repo_dir))
+
+    return repo_dir
+
+
+def copy_instruction_files(
+    repo_dir: Path, instruction_types: List[str], target_dir: Path
+):
+    """Copy instruction files from the repository to the target directory."""
+    copied_items = []
+
+    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]
+
+        # Copy directories
+        for dir_name in config["directories"]:
+            source_dir = repo_dir / dir_name
+            target_subdir = target_dir / dir_name
+
+            if source_dir.exists():
+                logger.info(
+                    "Copying directory",
+                    source=str(source_dir),
+                    target=str(target_subdir),
+                )
+
+                # Create target directory
+                target_subdir.mkdir(parents=True, exist_ok=True)
+
+                # Copy all files from source to target
+                copy_directory_contents(
+                    source_dir, target_subdir, config.get("exclude_patterns", [])
+                )
+                copied_items.append(f"{dir_name}/")
+
+        # Copy individual files
+        for file_name in config["files"]:
+            source_file = repo_dir / file_name
+            target_file = target_dir / file_name
+
+            if source_file.exists():
+                logger.info(
+                    "Copying file", source=str(source_file), target=str(target_file)
+                )
+
+                # Create parent directories if needed
+                target_file.parent.mkdir(parents=True, exist_ok=True)
+
+                # Copy file
+                target_file.write_bytes(source_file.read_bytes())
+                copied_items.append(file_name)
+
+    return copied_items
+
+
+def copy_directory_contents(
+    source_dir: Path, target_dir: Path, exclude_patterns: List[str]
+):
+    """Recursively copy directory contents, excluding specified patterns."""
+    for item in source_dir.rglob("*"):
+        if item.is_file():
+            relative_path = item.relative_to(source_dir)
+            relative_str = str(relative_path)
+
+            # Check if file matches any exclude pattern
+            should_exclude = False
+            for pattern in exclude_patterns:
+                if pattern.endswith("/*"):
+                    # Pattern like "workflows/*" - exclude if path starts with "workflows/"
+                    pattern_prefix = pattern[:-1]  # Remove the "*"
+                    if relative_str.startswith(pattern_prefix):
+                        should_exclude = True
+                        break
+                elif relative_str == pattern:
+                    should_exclude = True
+                    break
+
+            if should_exclude:
+                logger.debug("Excluding file", file=relative_str, pattern=pattern)
+                continue
+
+            target_file = target_dir / relative_path
+            target_file.parent.mkdir(parents=True, exist_ok=True)
+            target_file.write_bytes(item.read_bytes())
+
+
+def download_main(
+    instruction_types: Annotated[
+        List[str],
+        typer.Argument(
+            help="Types of instructions to download (cursor, github, gemini, claude, agent). Downloads everything by default."
+        ),
+    ] = None,
+    repo: Annotated[
+        str, typer.Option("--repo", "-r", help="GitHub repository to download from")
+    ] = DEFAULT_REPO,
+    branch: Annotated[
+        str, typer.Option("--branch", "-b", help="Branch to download from")
+    ] = DEFAULT_BRANCH,
+    target_dir: Annotated[
+        str, typer.Option("--target", "-t", help="Target directory to download to")
+    ] = ".",
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
+    ] = False,
+):
+    """Download LLM instruction files from GitHub repositories.
+
+    This command replaces the legacy download.sh script and provides more flexibility
+    in selecting what to download and from which repository.
+
+    Examples:
+
+    \b
+    # Download everything from the default repository
+    llm_ide_rules download
+
+    \b
+    # Download only Cursor and GitHub instructions
+    llm_ide_rules download cursor github
+
+    \b
+    # Download from a different repository
+    llm_ide_rules download --repo other-user/other-repo
+
+    \b
+    # Download to a specific directory
+    llm_ide_rules download --target ./my-project
+    """
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG)
+        structlog.configure(
+            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+        )
+
+    # Use default types if none specified
+    if not instruction_types:
+        instruction_types = DEFAULT_TYPES
+
+    # Validate instruction 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()
+
+    logger.info(
+        "Starting download",
+        repo=repo,
+        branch=branch,
+        instruction_types=instruction_types,
+        target_dir=str(target_path),
+    )
+
+    # Download and extract repository
+    repo_dir = download_and_extract_repo(repo, branch)
+
+    try:
+        # Copy instruction files
+        copied_items = copy_instruction_files(repo_dir, instruction_types, target_path)
+
+        if copied_items:
+            logger.info("Download completed successfully", copied_items=copied_items)
+            typer.echo(f"Downloaded {len(copied_items)} items to {target_path}:")
+            for item in copied_items:
+                typer.echo(f"  - {item}")
+        else:
+            logger.warning("No files were copied")
+            typer.echo("No matching instruction files found in the repository.")
+
+    finally:
+        # Clean up temporary directory
+        import shutil
+
+        shutil.rmtree(repo_dir.parent.parent, ignore_errors=True)

llm_ide_rules/commands/explode.py

@@ -0,0 +1,336 @@
+"""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()
+
+
+def generate_cursor_frontmatter(glob):
+    """Generate Cursor rule frontmatter for a given glob pattern."""
+    return f"""---
+description:
+globs: {glob}
+alwaysApply: false
+---
+"""
+
+
+def generate_copilot_frontmatter(glob):
+    """Generate Copilot instruction frontmatter for a given glob pattern."""
+    return f"""---
+applyTo: "{glob}"
+---
+"""
+
+
+def extract_general(lines):
+    """
+    Extract lines before the first section header '## '.
+    """
+    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 description, filtered_content
+
+
+def write_cursor_prompt(content_lines, filename, prompts_dir, section_name=None):
+    """Write a Cursor prompt file with frontmatter including description."""
+    filepath = os.path.join(prompts_dir, filename + ".mdc")
+
+    # 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
+    )
+
+    with open(filepath, "w") as f:
+        # Only add frontmatter if description is not empty
+        if description:
+            frontmatter = f"""---
+description: {description}
+---
+"""
+            f.write(frontmatter)
+
+        for line in filtered_content:
+            f.write(line)
+
+
+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")
+
+    # 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
+    )
+
+    frontmatter = f"""---
+mode: 'agent'
+description: '{description}'
+---
+"""
+
+    with open(filepath, "w") as f:
+        f.write(frontmatter)
+        for line in filtered_content:
+            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)."""
+    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
+        )
+
+        # Create prompt files (same as None case in SECTION_GLOBS)
+        write_cursor_prompt(section_content, filename, rules_dir, section_name)
+        write_github_prompt(section_content, filename, github_prompts_dir, section_name)
+        return True
+    return False
+
+
+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,
+):
+    """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")
+    copilot_dir = os.path.join(os.getcwd(), ".github", "instructions")
+    github_prompts_dir = os.path.join(os.getcwd(), ".github", "prompts")
+
+    os.makedirs(rules_dir, exist_ok=True)
+    os.makedirs(copilot_dir, exist_ok=True)
+    os.makedirs(github_prompts_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 prompt - create prompt files using the original section name for header
+                write_cursor_prompt(section_content, filename, rules_dir, section_name)
+                write_github_prompt(
+                    section_content, filename, github_prompts_dir, section_name
+                )
+
+    # 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)
+    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, rules_dir, github_prompts_dir
+                ):
+                    processed_unmapped.add(section_name)
+
+    logger.info(
+        "Explode operation completed",
+        cursor_rules=rules_dir,
+        copilot_instructions=copilot_dir,
+        github_prompts=github_prompts_dir,
+    )
+    typer.echo(
+        "Created Cursor rules in .cursor/rules/, Copilot instructions in .github/instructions/, and prompts in respective directories"
+    )

llm_ide_rules/commands/implode.py

@@ -0,0 +1,218 @@
+"""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}")
+

llm_ide_rules/constants.py

@@ -0,0 +1,36 @@
+"""Shared constants for explode and implode functionality."""
+
+import json
+import os
+from pathlib import Path
+
+def load_section_globs(custom_config_path: str = None) -> dict:
+    """Load section globs from JSON config file.
+    
+    Args:
+        custom_config_path: Path to custom configuration file to override defaults
+    
+    Returns:
+        Dictionary mapping section headers to their file globs or None for prompts
+    """
+    if custom_config_path and os.path.exists(custom_config_path):
+        config_path = Path(custom_config_path)
+    else:
+        # Load default bundled config
+        config_path = Path(__file__).parent / "sections.json"
+    
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+    
+    return config["section_globs"]
+
+# Default section globs - loaded from bundled JSON
+SECTION_GLOBS = load_section_globs()
+
+def header_to_filename(header):
+    """Convert a section header to a filename."""
+    return header.lower().replace(' ', '-')
+
+def filename_to_header(filename):
+    """Convert a filename back to a section header."""
+    return filename.replace('-', ' ').title()

llm_ide_rules/sections.json

@@ -0,0 +1,18 @@
+{
+  "section_globs": {
+    "Python": "**/*.py",
+    "Python App": "**/*.py",
+    "Pytest Integration Tests": "tests/integration/**/*.py",
+    "Pytest Tests": "tests/**/*.py",
+    "Python Route Tests": "tests/routes/**/*.py",
+    "Alembic Migrations": "migrations/versions/*.py",
+    "FastAPI": "app/routes/**/*.py",
+    "React": "**/*.tsx",
+    "React Router": "web/app/routes/**/*.tsx",
+    "React Router Client Loader": null,
+    "Shell": "**/*.sh",
+    "TypeScript": "**/*.ts,**/*.tsx",
+    "TypeScript DocString": null,
+    "Secrets": null
+  }
+}

llm_ide_rules-0.2.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.3
+Name: llm-ide-rules
+Version: 0.2.0
+Summary: CLI tool for managing LLM IDE prompts and rules
+Keywords: llm,ide,prompts,cursor,copilot
+Author: Michael Bianco
+Author-email: Michael Bianco <mike@mikebian.co>
+Requires-Dist: typer>=0.9.0
+Requires-Dist: structlog>=23.2.0
+Requires-Dist: requests>=2.25.0
+Requires-Python: >=3.9
+Project-URL: Repository, https://github.com/iloveitaly/llm-ide-rules
+Description-Content-Type: text/markdown
+
+# Copilot & Cursor LLM Instructions
+
+Going to try to centralize all my prompts in a single place and create some scripts to help convert from copilot to cursor, etc.
+
+I don't want to be tied to a specific IDE and it's a pain to have to edit instructions for various languages across a ton of different files.
+
+Additionally, it becomes challenging to copy these prompts into various projects and contribute them back to a single location.
+
+Some of the glob assumptions in this repo are specific to how I've chosen to organize python and typescript [in the python starter template](https://github.com/iloveitaly/python-starter-template) and what tooling (fastapi, etc) that I've chosen to use.
+
+## Installation
+
+You can run the `llm-ide-rules` CLI tool using uvx:
+
+```sh
+uvx llm-ide-rules
+```
+
+Or install from the repository:
+
+```sh
+uv tool install git+https://github.com/iloveitaly/llm-ide-rules.git
+```
+
+```sh
+git clone https://github.com/iloveitaly/llm-ide-rules.git
+cd llm-ide-rules
+uv sync
+source .venv/bin/activate
+```
+
+## Usage
+
+### CLI Commands
+
+The `llm-ide-rules` CLI provides commands to manage LLM IDE prompts and rules:
+
+```sh
+# Convert instruction file to separate rule files
+uvx llm-ide-rules explode [input_file]
+
+# Bundle rule files back into a single instruction file
+uvx llm-ide-rules implode cursor [output_file]     # Bundle Cursor rules
+uvx llm-ide-rules implode github [output_file]    # Bundle GitHub/Copilot instructions
+
+# Download instruction files from repositories
+uvx llm-ide-rules download [instruction_types]    # Download everything by default
+uvx llm-ide-rules download cursor github          # Download specific types
+uvx llm-ide-rules download --repo other/repo      # Download from different repo
+
+
+```
+
+### Examples
+
+```sh
+# Explode instructions.md into .cursor/rules/ and .github/instructions/
+uvx llm-ide-rules explode instructions.md
+
+# Bundle Cursor rules back into a single file
+uvx llm-ide-rules implode cursor bundled-instructions.md
+
+# Bundle GitHub instructions with verbose logging
+uvx llm-ide-rules implode github --verbose instructions.md
+
+# Download everything from default repository
+uvx llm-ide-rules download
+
+# Download only specific instruction types
+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
+```
+
+## Development
+
+### Using the CLI for Development
+
+The CLI replaces the old standalone scripts. Use the CLI commands in your development workflow:
+
+```shell
+# Setup the environment
+uv sync
+
+# Explode instructions into separate rule files
+uvx llm-ide-rules explode
+
+# Bundle rules back into instructions
+uvx llm-ide-rules implode cursor instructions.md
+```
+
+### Building and Testing
+
+```shell
+# Build the package
+uv build
+
+# Run tests
+pytest
+```
+
+## Extracting Changes
+
+The idea of this repo is you'll copy prompts into your various projects. Then, if you improve a prompt in a project, you can pull that change into this upstream repo.
+
+Here's how to do it:
+
+```shell
+git diff .github/instructions | pbcopy
+pbpaste | gpatch -p1
+```
+
+`gpatch` is an updated version of patch on macOS that seems to work much better for me.
+
+## Related Links
+
+* https://cursor.directory/rules
+* https://github.com/PatrickJS/awesome-cursorrules
+* https://www.cursorprompts.org

llm_ide_rules-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+llm_ide_rules/__init__.py,sha256=5e9eb7da379af4afc29d611b5ac13578601a705c188b0c31466afa1e95f779a6,1109
+llm_ide_rules/__main__.py,sha256=881447dbad0fe837590fa8224f1d0dd70416fd5344779978d07744ff8e0cf868,144
+llm_ide_rules/commands/download.py,sha256=8c1be22a0d2886fe60fa39e628fdd878fc8455fa4fb725c611510f17c415a2f8,8297
+llm_ide_rules/commands/explode.py,sha256=a8ace601155055a0061e47da7e99a672334796f1ebb91b24c3adf905f65e1645,11196
+llm_ide_rules/commands/implode.py,sha256=35282bfc83be808f12e9e9ce7af1bae4069e53bd8f441948e3551339b2e9418d,8847
+llm_ide_rules/constants.py,sha256=1182b9757ca58d038a4878d1b55570aac4f0287f1a5ab5af8d68331b799b0686,1118
+llm_ide_rules/sections.json,sha256=9ed1725e44d8a29364e5ac3f01e0e6e03ff17cd45c280846659b7f73940b668b,549
+llm_ide_rules-0.2.0.dist-info/WHEEL,sha256=0f7d664a881437bddec71c703c3c2f01fd13581519f95130abcc96e296ef0426,79
+llm_ide_rules-0.2.0.dist-info/entry_points.txt,sha256=8d46b50bb8cd4b45ee57936d452d9f7bc9d9c4fb3f7d5b134f4e5d21db05b84d,54
+llm_ide_rules-0.2.0.dist-info/METADATA,sha256=9dedabc6b39b99b4e1593dc1b36df41986653fb2601ae1cf84f8187669613a1a,3777
+llm_ide_rules-0.2.0.dist-info/RECORD,,

llm_ide_rules-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.11
+Root-Is-Purelib: true
+Tag: py3-none-any

llm_ide_rules-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+llm_ide_rules = llm_ide_rules:main
+