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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llm-ide-rules
-Version: 0.4.0
+Version: 0.5.0
 Summary: CLI tool for managing LLM IDE prompts and rules
 Keywords: llm,ide,prompts,cursor,copilot
 Author: Michael Bianco

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

@@ -1,6 +1,6 @@
 [project]
 name = "llm-ide-rules"
-version = "0.4.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.4.0 → llm_ide_rules-0.5.0}/src/llm_ide_rules/__init__.py

@@ -4,11 +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.4.0"
+__version__ = "0.5.0"
 
 app = typer.Typer(
     name="llm_ide_rules",
@@ -23,8 +23,10 @@ app.command("delete", help="Remove downloaded LLM instruction files")(delete_mai
 
 # 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.4.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.4.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.4.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}")
-