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

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/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/commands/implode.py

@@ -57,15 +57,18 @@ def get_ordered_files_github(file_list, section_globs_keys):
     return ordered_files
 
 
-def bundle_cursor_rules(rules_dir, output_file, section_globs):
-    """Bundle Cursor rule files into a single file."""
+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 = general + ordered_others
+    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.
@@ -117,14 +120,32 @@ def strip_header(text):
     return text
 
 
-def bundle_github_instructions(instructions_dir, output_file, section_globs):
-    """Bundle GitHub instruction files into a single file."""
+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_files = get_ordered_files_github(instr_files, section_globs.keys())
+    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.
@@ -144,7 +165,7 @@ def bundle_github_instructions(instructions_dir, output_file, section_globs):
             if content:
                 out.write(content)
                 out.write("\n\n")
-        for instr_file in ordered_files:
+        for instr_file in ordered_instructions:
             with open(instr_file, "r") as f:
                 content = f.read().strip()
                 if not content:
@@ -157,6 +178,107 @@ def bundle_github_instructions(instructions_dir, output_file, section_globs):
                 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(
@@ -164,28 +286,29 @@ def cursor(
     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."""
+    """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", rules_dir=rules_dir, output_file=output_path, config=config)
-    
+
+    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, output_path, SECTION_GLOBS)
-    logger.info("Cursor rules bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled cursor rules into {output}")
+
+    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(
@@ -193,26 +316,85 @@ def github(
     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."""
+    """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", instructions_dir=instructions_dir, output_file=output_path, config=config)
-    
+
+    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, output_path, SECTION_GLOBS)
-    logger.info("GitHub instructions bundled successfully", output_file=output_path)
-    typer.echo(f"Bundled github instructions into {output}")
+
+    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/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.dist-info → llm_ide_rules-0.5.0.dist-info}/METADATA

@@ -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.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+llm_ide_rules/__init__.py,sha256=494c58df084291e4e427a1a36f78306224ea83305531dcff5c566c2fb53e16ce,1472
+llm_ide_rules/__main__.py,sha256=881447dbad0fe837590fa8224f1d0dd70416fd5344779978d07744ff8e0cf868,144
+llm_ide_rules/commands/delete.py,sha256=6ed0a44b1be1d950180831681d79e3a0be91cd37296e30e7a0d821d49292ebf4,5812
+llm_ide_rules/commands/download.py,sha256=06c2a841db5fe0b0f7f3e8c99ad198c8e07e53d8801fb4d95e802ecee60cda31,11022
+llm_ide_rules/commands/explode.py,sha256=59df4bb542397c9204332ba563a95c49d236a82ebc6af81378b2798f8adc2e77,14779
+llm_ide_rules/commands/implode.py,sha256=f3e9ff754530c06d7eacb20fc37ae8d958218f02df2a0f48eac1d5c6a9a749be,16743
+llm_ide_rules/constants.py,sha256=1182b9757ca58d038a4878d1b55570aac4f0287f1a5ab5af8d68331b799b0686,1118
+llm_ide_rules/sections.json,sha256=e82bf37f8a7bd919c881d7cc084cdfd82e1f9e6ff5385c74b18c14996bcac3c1,822
+llm_ide_rules-0.5.0.dist-info/WHEEL,sha256=0f7d664a881437bddec71c703c3c2f01fd13581519f95130abcc96e296ef0426,79
+llm_ide_rules-0.5.0.dist-info/entry_points.txt,sha256=c6c00b5d607048489fcfed8c8a47bbb364b0a8dbb5b5a2ecffe11c986ace35e3,54
+llm_ide_rules-0.5.0.dist-info/METADATA,sha256=af671c42110d55d0670a3aef9007b890dcb5d6335add807d36d8baadf3e802a3,4898
+llm_ide_rules-0.5.0.dist-info/RECORD,,

llm_ide_rules-0.4.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-llm_ide_rules/__init__.py,sha256=03b18e9945a42a481e3f4c345ee9550792b83496bee0a708bafad8d7c6dfcf17,1246
-llm_ide_rules/__main__.py,sha256=881447dbad0fe837590fa8224f1d0dd70416fd5344779978d07744ff8e0cf868,144
-llm_ide_rules/commands/delete.py,sha256=6ed0a44b1be1d950180831681d79e3a0be91cd37296e30e7a0d821d49292ebf4,5812
-llm_ide_rules/commands/download.py,sha256=06c2a841db5fe0b0f7f3e8c99ad198c8e07e53d8801fb4d95e802ecee60cda31,11022
-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.4.0.dist-info/WHEEL,sha256=0f7d664a881437bddec71c703c3c2f01fd13581519f95130abcc96e296ef0426,79
-llm_ide_rules-0.4.0.dist-info/entry_points.txt,sha256=c6c00b5d607048489fcfed8c8a47bbb364b0a8dbb5b5a2ecffe11c986ace35e3,54
-llm_ide_rules-0.4.0.dist-info/METADATA,sha256=dfa81f3d0100761f18547dd23e3c15343c6f8341ab27622b6b89b59860bb3ebe,4898
-llm_ide_rules-0.4.0.dist-info/RECORD,,