llm-ide-rules 0.6.0__tar.gz → 0.7.0__tar.gz

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: llm-ide-rules
-Version: 0.6.0
+Version: 0.7.0
 Summary: CLI tool for managing LLM IDE prompts and rules
 Keywords: llm,ide,prompts,cursor,copilot
 Author: Michael Bianco
@@ -11,6 +11,7 @@ Requires-Dist: requests>=2.25.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: json5>=0.9.0
 Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: markdown-it-py>=4.0.0
 Requires-Python: >=3.11
 Project-URL: Repository, https://github.com/iloveitaly/llm-ide-rules
 Description-Content-Type: text/markdown

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/pyproject.toml

@@ -1,11 +1,19 @@
 [project]
 name = "llm-ide-rules"
-version = "0.6.0"
+version = "0.7.0"
 description = "CLI tool for managing LLM IDE prompts and rules"
 keywords = ["llm", "ide", "prompts", "cursor", "copilot"]
 readme = "README.md"
 requires-python = ">=3.11"
-dependencies = ["typer>=0.9.0", "structlog-config>=0.6.0", "requests>=2.25.0", "pydantic>=2.0.0", "json5>=0.9.0", "tomli-w>=1.0.0"]
+dependencies = [
+    "typer>=0.9.0",
+    "structlog-config>=0.6.0",
+    "requests>=2.25.0",
+    "pydantic>=2.0.0",
+    "json5>=0.9.0",
+    "tomli-w>=1.0.0",
+    "markdown-it-py>=4.0.0",
+]
 authors = [{ name = "Michael Bianco", email = "mike@mikebian.co" }]
 urls = { "Repository" = "https://github.com/iloveitaly/llm-ide-rules" }
 

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/__init__.py

@@ -14,7 +14,7 @@ from llm_ide_rules.commands.download import download_main
 from llm_ide_rules.commands.delete import delete_main
 from llm_ide_rules.commands.mcp import mcp_app
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 app = typer.Typer(
     name="llm_ide_rules",

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/base.py

@@ -23,14 +23,14 @@ class BaseAgent(ABC):
 
     @abstractmethod
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle rule files into a single output file."""
         ...
 
     @abstractmethod
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle command files into a single output file."""
         ...
@@ -57,6 +57,40 @@ class BaseAgent(ABC):
         """Write a single command file."""
         ...
 
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+    ) -> None:
+        """Generate a root documentation file (e.g. CLAUDE.md) if supported."""
+        pass
+
+    def build_root_doc_content(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+    ) -> str:
+        """Build the content string for a root documentation file by aggregating rules."""
+        content = []
+
+        # Add general instructions
+        if general_lines:
+            trimmed = trim_content(general_lines)
+            if trimmed:
+                content.extend(trimmed)
+                content.append("\n\n")
+
+        # Add sections in document order (dict maintains insertion order in Python 3.7+)
+        for section_name, lines in rules_sections.items():
+            trimmed = trim_content(lines)
+            if trimmed:
+                content.extend(trimmed)
+                content.append("\n\n")
+
+        return "".join(content).strip() + "\n" if content else ""
+
     def get_rules_path(self, base_dir: Path) -> Path:
         """Get the full path to the rules directory."""
         if not self.rules_dir:
@@ -155,9 +189,15 @@ def strip_toml_metadata(text: str) -> str:
 
 
 def get_ordered_files(
-    file_list: list[Path], section_globs_keys: list[str]
+    file_list: list[Path], section_globs_keys: list[str] | None = None
 ) -> list[Path]:
-    """Order files based on section_globs key order, with unmapped files at the end."""
+    """Order files based on section_globs key order, with unmapped files at the end.
+
+    If section_globs_keys is None, returns files sorted alphabetically.
+    """
+    if not section_globs_keys:
+        return sorted(file_list, key=lambda p: p.name)
+
     file_dict = {f.stem: f for f in file_list}
     ordered_files = []
 
@@ -174,9 +214,15 @@ def get_ordered_files(
 
 
 def get_ordered_files_github(
-    file_list: list[Path], section_globs_keys: list[str]
+    file_list: list[Path], section_globs_keys: list[str] | None = None
 ) -> list[Path]:
-    """Order GitHub instruction files, handling .instructions suffix."""
+    """Order GitHub instruction files, handling .instructions suffix.
+
+    If section_globs_keys is None, returns files sorted alphabetically.
+    """
+    if not section_globs_keys:
+        return sorted(file_list, key=lambda p: p.name)
+
     file_dict = {}
     for f in file_list:
         base_stem = f.stem.replace(".instructions", "")

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/claude.py

@@ -23,13 +23,13 @@ class ClaudeAgent(BaseAgent):
     mcp_project_path = ".mcp.json"
 
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Claude Code doesn't support rules, only commands."""
         return False
 
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle Claude Code command files (.md) into a single output file."""
         commands_dir = self.commands_dir
@@ -48,7 +48,9 @@ class ClaudeAgent(BaseAgent):
         if not command_files:
             return False
 
-        ordered_commands = get_ordered_files(command_files, list(section_globs.keys()))
+        ordered_commands = get_ordered_files(
+            command_files, list(section_globs.keys()) if section_globs else None
+        )
 
         content_parts: list[str] = []
         for command_file in ordered_commands:
@@ -56,7 +58,9 @@ class ClaudeAgent(BaseAgent):
             if not content:
                 continue
 
-            header = resolve_header_from_stem(command_file.stem, section_globs)
+            header = resolve_header_from_stem(
+                command_file.stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")
@@ -90,3 +94,15 @@ class ClaudeAgent(BaseAgent):
 
         trimmed = trim_content(content_lines)
         filepath.write_text("".join(trimmed))
+
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+    ) -> None:
+        """Generate CLAUDE.md from rules."""
+        content = self.build_root_doc_content(general_lines, rules_sections)
+        if content.strip():
+            (output_dir / "CLAUDE.md").write_text(content)

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/cursor.py

@@ -27,7 +27,7 @@ class CursorAgent(BaseAgent):
     mcp_project_path = ".cursor/mcp.json"
 
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle Cursor rule files (.mdc) into a single output file."""
         rules_dir = self.rules_dir
@@ -45,18 +45,35 @@ class CursorAgent(BaseAgent):
         general = [f for f in rule_files if f.stem == "general"]
         others = [f for f in rule_files if f.stem != "general"]
 
-        ordered_others = get_ordered_files(others, list(section_globs.keys()))
+        ordered_others = get_ordered_files(
+            others, list(section_globs.keys()) if section_globs else None
+        )
         ordered = general + ordered_others
 
         content_parts: list[str] = []
         for rule_file in ordered:
-            content = rule_file.read_text().strip()
-            if not content:
+            file_content = rule_file.read_text().strip()
+            if not file_content:
                 continue
 
-            content = strip_yaml_frontmatter(content)
+            # Extract header from file content before stripping it
+            lines = file_content.splitlines()
+            extracted_header = None
+            for line in lines:
+                if line.startswith("## "):
+                    extracted_header = line[3:].strip()
+                    break
+
+            content = strip_yaml_frontmatter(file_content)
             content = strip_header(content)
-            header = resolve_header_from_stem(rule_file.stem, section_globs)
+
+            # Use extracted header if available, otherwise resolve from filename
+            if extracted_header:
+                header = extracted_header
+            else:
+                header = resolve_header_from_stem(
+                    rule_file.stem, section_globs if section_globs else {}
+                )
 
             if rule_file.stem != "general":
                 content_parts.append(f"## {header}\n\n")
@@ -71,7 +88,7 @@ class CursorAgent(BaseAgent):
         return True
 
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle Cursor command files (.md) into a single output file."""
         commands_dir = self.commands_dir
@@ -90,7 +107,9 @@ class CursorAgent(BaseAgent):
         if not command_files:
             return False
 
-        ordered_commands = get_ordered_files(command_files, list(section_globs.keys()))
+        ordered_commands = get_ordered_files(
+            command_files, list(section_globs.keys()) if section_globs else None
+        )
 
         content_parts: list[str] = []
         for command_file in ordered_commands:
@@ -98,7 +117,9 @@ class CursorAgent(BaseAgent):
             if not content:
                 continue
 
-            header = resolve_header_from_stem(command_file.stem, section_globs)
+            header = resolve_header_from_stem(
+                command_file.stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/gemini.py

@@ -27,13 +27,13 @@ class GeminiAgent(BaseAgent):
     mcp_project_path = ".gemini/settings.json"
 
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Gemini CLI doesn't support rules, only commands."""
         return False
 
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle Gemini CLI command files (.toml) into a single output file."""
         commands_dir = self.commands_dir
@@ -52,7 +52,9 @@ class GeminiAgent(BaseAgent):
         if not command_files:
             return False
 
-        ordered_commands = get_ordered_files(command_files, list(section_globs.keys()))
+        ordered_commands = get_ordered_files(
+            command_files, list(section_globs.keys()) if section_globs else None
+        )
 
         content_parts: list[str] = []
         for command_file in ordered_commands:
@@ -61,7 +63,9 @@ class GeminiAgent(BaseAgent):
                 continue
 
             content = strip_toml_metadata(content)
-            header = resolve_header_from_stem(command_file.stem, section_globs)
+            header = resolve_header_from_stem(
+                command_file.stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")
@@ -159,3 +163,15 @@ class GeminiAgent(BaseAgent):
 
         existing[self.mcp_root_key] = servers
         path.write_text(json.dumps(existing, indent=2))
+
+    def generate_root_doc(
+        self,
+        general_lines: list[str],
+        rules_sections: dict[str, list[str]],
+        command_sections: dict[str, list[str]],
+        output_dir: Path,
+    ) -> None:
+        """Generate GEMINI.md from rules."""
+        content = self.build_root_doc_content(general_lines, rules_sections)
+        if content.strip():
+            (output_dir / "GEMINI.md").write_text(content)

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/github.py

@@ -28,7 +28,7 @@ class GitHubAgent(BaseAgent):
     mcp_project_path = ".copilot/mcp-config.json"
 
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle GitHub instruction files into a single output file."""
         rules_dir = self.rules_dir
@@ -46,7 +46,7 @@ class GitHubAgent(BaseAgent):
         instr_files = list(instructions_path.glob(f"*{rule_ext}"))
 
         ordered_instructions = get_ordered_files_github(
-            instr_files, list(section_globs.keys())
+            instr_files, list(section_globs.keys()) if section_globs else None
         )
 
         content_parts: list[str] = []
@@ -64,7 +64,9 @@ class GitHubAgent(BaseAgent):
             content = strip_yaml_frontmatter(content)
             content = strip_header(content)
             base_stem = instr_file.stem.replace(".instructions", "")
-            header = resolve_header_from_stem(base_stem, section_globs)
+            header = resolve_header_from_stem(
+                base_stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")
@@ -76,7 +78,7 @@ class GitHubAgent(BaseAgent):
         return True
 
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle GitHub prompt files into a single output file."""
         commands_dir = self.commands_dir
@@ -101,11 +103,12 @@ class GitHubAgent(BaseAgent):
             prompt_dict[base_stem] = f
 
         ordered_prompts = []
-        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]
+        if section_globs:
+            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]
 
         remaining_prompts = sorted(prompt_dict.values(), key=lambda p: p.name)
         ordered_prompts.extend(remaining_prompts)
@@ -119,7 +122,9 @@ class GitHubAgent(BaseAgent):
             content = strip_yaml_frontmatter(content)
             content = strip_header(content)
             base_stem = prompt_file.stem.replace(".prompt", "")
-            header = resolve_header_from_stem(base_stem, section_globs)
+            header = resolve_header_from_stem(
+                base_stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/agents/opencode.py

@@ -25,13 +25,13 @@ class OpenCodeAgent(BaseAgent):
     mcp_root_key = "mcp"
 
     def bundle_rules(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """OpenCode doesn't support rules."""
         return False
 
     def bundle_commands(
-        self, output_file: Path, section_globs: dict[str, str | None]
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
     ) -> bool:
         """Bundle OpenCode command files (.md) into a single output file."""
         commands_dir = self.commands_dir
@@ -50,7 +50,9 @@ class OpenCodeAgent(BaseAgent):
         if not command_files:
             return False
 
-        ordered_commands = get_ordered_files(command_files, list(section_globs.keys()))
+        ordered_commands = get_ordered_files(
+            command_files, list(section_globs.keys()) if section_globs else None
+        )
 
         content_parts: list[str] = []
         for command_file in ordered_commands:
@@ -58,7 +60,9 @@ class OpenCodeAgent(BaseAgent):
             if not content:
                 continue
 
-            header = resolve_header_from_stem(command_file.stem, section_globs)
+            header = resolve_header_from_stem(
+                command_file.stem, section_globs if section_globs else {}
+            )
             content_parts.append(f"## {header}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/commands/download.py

@@ -9,6 +9,8 @@ import requests
 import typer
 from typing_extensions import Annotated
 
+from llm_ide_rules.commands.explode import explode_implementation
+from llm_ide_rules.constants import VALID_AGENTS
 from llm_ide_rules.log import log
 
 DEFAULT_REPO = "iloveitaly/llm-ide-rules"
@@ -38,15 +40,36 @@ def normalize_repo(repo: str) -> str:
 
 
 # Define what files/directories each instruction type includes
+# For agents supported by 'explode' (cursor, github, gemini, claude, opencode),
+# we don't download specific directories anymore. Instead, we download the source
+# files (instructions.md, commands.md) and generate them locally using explode.
+# The directories listed here are what gets created by explode and what delete removes.
 INSTRUCTION_TYPES = {
-    "cursor": {"directories": [".cursor"], "files": []},
+    "cursor": {
+        "directories": [".cursor"],
+        "files": [],
+        "include_patterns": [],
+    },
     "github": {
-        "directories": [".github"],
+        "directories": [".github/instructions", ".github/prompts"],
+        "files": [".github/copilot-instructions.md"],
+        "include_patterns": [],
+    },
+    "gemini": {
+        "directories": [".gemini"],
+        "files": ["GEMINI.md"],
+        "include_patterns": [],
+    },
+    "claude": {
+        "directories": [".claude"],
+        "files": ["CLAUDE.md"],
+        "include_patterns": [],
+    },
+    "opencode": {
+        "directories": [".opencode"],
         "files": [],
-        "exclude_patterns": ["workflows/*"],
+        "include_patterns": [],
     },
-    "gemini": {"directories": [".gemini/commands"], "files": ["GEMINI.md"]},
-    "claude": {"directories": [".claude/commands"], "files": ["CLAUDE.md"]},
     "agent": {"directories": [], "files": ["AGENT.md"]},
     "agents": {"directories": [], "files": [], "recursive_files": ["AGENTS.md"]},
 }
@@ -131,7 +154,10 @@ def copy_instruction_files(
 
                 # Copy all files from source to target
                 copy_directory_contents(
-                    source_dir, target_subdir, config.get("exclude_patterns", [])
+                    source_dir,
+                    target_subdir,
+                    config.get("exclude_patterns", []),
+                    config.get("include_patterns", []),
                 )
                 copied_items.append(f"{dir_name}/")
 
@@ -208,7 +234,10 @@ def copy_recursive_files(
 
 
 def copy_directory_contents(
-    source_dir: Path, target_dir: Path, exclude_patterns: list[str]
+    source_dir: Path,
+    target_dir: Path,
+    exclude_patterns: list[str],
+    include_patterns: list[str] = [],
 ):
     """Recursively copy directory contents, excluding specified patterns."""
     for item in source_dir.rglob("*"):
@@ -234,6 +263,22 @@ def copy_directory_contents(
                 log.debug("excluding file", file=relative_str, pattern=pattern)
                 continue
 
+            # Check if file matches any include pattern (if any provided)
+            if include_patterns:
+                matched_include = False
+                for include_pattern in include_patterns:
+                    # Match against filename only, or full relative path
+                    if item.match(include_pattern):
+                        matched_include = True
+                        break
+
+                if not matched_include:
+                    log.debug(
+                        "skipping file (not matched in include_patterns)",
+                        file=relative_str,
+                    )
+                    continue
+
             target_file = target_dir / relative_path
             target_file.parent.mkdir(parents=True, exist_ok=True)
             target_file.write_bytes(item.read_bytes())
@@ -312,13 +357,58 @@ def download_main(
         # Copy instruction files
         copied_items = copy_instruction_files(repo_dir, instruction_types, target_path)
 
+        # Check for source files (instructions.md, commands.md) and copy them if available
+        # These are needed for 'explode' logic
+        source_files = ["instructions.md", "commands.md"]
+        sources_copied = False
+
+        # Only copy source files if we have at least one agent that uses explode
+        has_explode_agent = any(t in VALID_AGENTS for t in instruction_types)
+
+        if has_explode_agent:
+            for source_file in source_files:
+                src = repo_dir / source_file
+                dst = target_path / source_file
+                if src.exists():
+                    log.info("copying source file", source=str(src), target=str(dst))
+                    dst.parent.mkdir(parents=True, exist_ok=True)
+                    dst.write_bytes(src.read_bytes())
+                    copied_items.append(source_file)
+                    sources_copied = True
+
+        # Generate rule files locally for supported agents
+        explodable_agents = [t for t in instruction_types if t in VALID_AGENTS]
+
+        if explodable_agents:
+            if not sources_copied:
+                # Check if they existed in target already?
+                if not (target_path / "instructions.md").exists():
+                    log.warning(
+                        "source file instructions.md missing, generation might fail"
+                    )
+
+            for agent in explodable_agents:
+                log.info("generating rules locally", agent=agent)
+                try:
+                    explode_implementation(
+                        input_file="instructions.md",
+                        agent=agent,
+                        working_dir=target_path,
+                    )
+                    copied_items.append(f"(generated) {agent} rules")
+                except Exception as e:
+                    log.error("failed to generate rules", agent=agent, error=str(e))
+                    typer.echo(
+                        f"Warning: Failed to generate rules for {agent}: {e}", err=True
+                    )
+
         if copied_items:
-            success_msg = f"Downloaded {len(copied_items)} items to {target_path}:"
+            success_msg = f"Downloaded/Generated items in {target_path}:"
             typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
             for item in copied_items:
                 typer.echo(f"  - {item}")
         else:
-            log.warning("no files were copied")
+            log.warning("no files were copied or generated")
             typer.echo("No matching instruction files found in the repository.")
 
     finally:

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/commands/explode.py

@@ -12,59 +12,8 @@ from llm_ide_rules.agents.base import (
     write_rule_file,
 )
 from llm_ide_rules.log import log
-from llm_ide_rules.constants import load_section_globs, header_to_filename, VALID_AGENTS
-
-
-def extract_general(lines: list[str]) -> list[str]:
-    """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: list[str], header: str) -> list[str]:
-    """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)
-
-    return content
-
-
-def extract_all_sections(lines: list[str]) -> dict[str, list[str]]:
-    """Extract all sections from lines, returning dict of section_name -> content_lines."""
-    sections: dict[str, list[str]] = {}
-    current_section: str | None = None
-    current_content: list[str] = []
-
-    for line in lines:
-        if line.startswith("## "):
-            if current_section:
-                sections[current_section] = current_content
-
-            current_section = line.strip()[3:]
-            current_content = [line]
-        elif current_section:
-            current_content.append(line)
-
-    if current_section:
-        sections[current_section] = current_content
-
-    return sections
+from llm_ide_rules.constants import header_to_filename, VALID_AGENTS
+from llm_ide_rules.markdown_parser import parse_sections
 
 
 def process_command_section(
@@ -112,24 +61,14 @@ def process_unmapped_as_always_apply(
     return True
 
 
-def explode_main(
-    input_file: Annotated[
-        str, typer.Argument(help="Input markdown file")
-    ] = "instructions.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
-    agent: Annotated[
-        str,
-        typer.Option(
-            "--agent",
-            "-a",
-            help="Agent to explode for (cursor, github, claude, gemini, or all)",
-        ),
-    ] = "all",
+def explode_implementation(
+    input_file: str = "instructions.md",
+    agent: str = "all",
+    working_dir: Path | None = None,
 ) -> None:
-    """Convert instruction file to separate rule files."""
+    """Core implementation of explode command."""
+    if working_dir is None:
+        working_dir = Path.cwd()
 
     if agent not in VALID_AGENTS:
         log.error("invalid agent", agent=agent, valid_agents=VALID_AGENTS)
@@ -139,14 +78,13 @@ def explode_main(
         typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         raise typer.Exit(1)
 
-    section_globs = load_section_globs(config)
-
     log.info(
-        "starting explode operation", input_file=input_file, agent=agent, config=config
+        "starting explode operation",
+        input_file=input_file,
+        agent=agent,
+        working_dir=str(working_dir),
     )
 
-    cwd = Path.cwd()
-
     # Initialize only the agents we need
     agents_to_process = []
     if agent == "all":
@@ -163,21 +101,21 @@ def explode_main(
 
         if agent_name in ["cursor", "github"]:
             # These agents have both rules and commands
-            rules_dir = cwd / agent_instances[agent_name].rules_dir
-            commands_dir = cwd / agent_instances[agent_name].commands_dir
+            rules_dir = working_dir / agent_instances[agent_name].rules_dir
+            commands_dir = working_dir / agent_instances[agent_name].commands_dir
             rules_dir.mkdir(parents=True, exist_ok=True)
             commands_dir.mkdir(parents=True, exist_ok=True)
             agent_dirs[agent_name] = {"rules": rules_dir, "commands": commands_dir}
         else:
             # claude, gemini, and opencode only have commands
-            commands_dir = cwd / agent_instances[agent_name].commands_dir
+            commands_dir = working_dir / agent_instances[agent_name].commands_dir
             commands_dir.mkdir(parents=True, exist_ok=True)
             agent_dirs[agent_name] = {"commands": commands_dir}
 
-    input_path = cwd / input_file
+    input_path = working_dir / input_file
 
     try:
-        lines = input_path.read_text().splitlines(keepends=True)
+        input_text = input_path.read_text()
     except FileNotFoundError:
         log.error("input file not found", input_file=str(input_path))
         error_msg = f"Input file not found: {input_path}"
@@ -185,13 +123,15 @@ def explode_main(
         raise typer.Exit(1)
 
     commands_path = input_path.parent / "commands.md"
-    commands_lines = []
+    commands_text = ""
     if commands_path.exists():
-        commands_lines = commands_path.read_text().splitlines(keepends=True)
+        commands_text = commands_path.read_text()
         log.info("found commands file", commands_file=str(commands_path))
 
+    # Parse instructions
+    general, instruction_sections = parse_sections(input_text)
+
     # Process general instructions for agents that support rules
-    general = extract_general(lines)
     if any(line.strip() for line in general):
         general_header = """
 ---
@@ -204,20 +144,52 @@ alwaysApply: true
                 agent_dirs["cursor"]["rules"] / "general.mdc", general_header, general
             )
         if "github" in agent_instances:
-            agent_instances["github"].write_general_instructions(general, cwd)
-
-    # Process mapped sections for agents that support rules
-    found_sections = set()
-    for section_name, glob_pattern 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)
-
-            section_content = replace_header_with_proper_casing(
-                section_content, section_name
-            )
+            agent_instances["github"].write_general_instructions(general, working_dir)
+
+    # Process sections for agents that support rules
+    rules_sections: dict[str, list[str]] = {}
+    section_globs: dict[str, str | None] = {}
+
+    for section_name, section_data in instruction_sections.items():
+        content = section_data.content
+        glob_pattern = section_data.glob_pattern
+
+        if not any(line.strip() for line in content):
+            continue
+
+        rules_sections[section_name] = content
+        section_globs[section_name] = glob_pattern
+        filename = header_to_filename(section_name)
+
+        section_content = replace_header_with_proper_casing(content, section_name)
 
+        if glob_pattern is None:
+            # No directive = alwaysApply
+            if "cursor" in agent_instances and "github" in agent_instances:
+                process_unmapped_as_always_apply(
+                    section_name,
+                    section_content,
+                    agent_instances["cursor"],
+                    agent_instances["github"],
+                    agent_dirs["cursor"]["rules"],
+                    agent_dirs["github"]["rules"],
+                )
+            elif "cursor" in agent_instances:
+                agent_instances["cursor"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["cursor"]["rules"],
+                    glob_pattern=None,
+                )
+            elif "github" in agent_instances:
+                agent_instances["github"].write_rule(
+                    section_content,
+                    filename,
+                    agent_dirs["github"]["rules"],
+                    glob_pattern=None,
+                )
+        elif glob_pattern != "manual":
+            # Has glob pattern = file-specific rule
             if "cursor" in agent_instances:
                 agent_instances["cursor"].write_rule(
                     section_content,
@@ -233,71 +205,30 @@ alwaysApply: true
                     glob_pattern,
                 )
 
-    for section_name in section_globs:
-        if section_name not in found_sections:
-            log.warning("section not found in file", section=section_name)
-
-    # Process unmapped sections for agents that support rules
-    if "cursor" in agent_instances or "github" in agent_instances:
-        for line in lines:
-            if line.startswith("## "):
-                section_name = line.strip()[3:]
-                if not any(
-                    section_name.lower() == mapped_section.lower()
-                    for mapped_section in section_globs
-                ):
-                    log.warning(
-                        "unmapped section in instructions.md, treating as always-apply rule",
-                        section=section_name,
-                    )
-                    section_content = extract_section(lines, f"## {section_name}")
-
-                    if "cursor" in agent_instances and "github" in agent_instances:
-                        process_unmapped_as_always_apply(
-                            section_name,
-                            section_content,
-                            agent_instances["cursor"],
-                            agent_instances["github"],
-                            agent_dirs["cursor"]["rules"],
-                            agent_dirs["github"]["rules"],
-                        )
-                    elif "cursor" in agent_instances:
-                        # Only cursor - write just cursor rules
-                        if any(line.strip() for line in section_content):
-                            filename = header_to_filename(section_name)
-                            section_content = replace_header_with_proper_casing(
-                                section_content, section_name
-                            )
-                            agent_instances["cursor"].write_rule(
-                                section_content,
-                                filename,
-                                agent_dirs["cursor"]["rules"],
-                                glob_pattern=None,
-                            )
-                    elif "github" in agent_instances:
-                        # Only github - write just github rules
-                        if any(line.strip() for line in section_content):
-                            filename = header_to_filename(section_name)
-                            section_content = replace_header_with_proper_casing(
-                                section_content, section_name
-                            )
-                            agent_instances["github"].write_rule(
-                                section_content,
-                                filename,
-                                agent_dirs["github"]["rules"],
-                                glob_pattern=None,
-                            )
-
     # Process commands for all agents
-    if commands_lines:
-        command_sections = extract_all_sections(commands_lines)
+    command_sections_data = {}
+    command_sections = {}
+    if commands_text:
+        _, command_sections_data = parse_sections(commands_text)
         agents = [agent_instances[name] for name in agents_to_process]
         command_dirs = {
             name: agent_dirs[name]["commands"] for name in agents_to_process
         }
 
-        for section_name, section_content in command_sections.items():
-            process_command_section(section_name, section_content, agents, command_dirs)
+        for section_name, section_data in command_sections_data.items():
+            command_sections[section_name] = section_data.content
+            process_command_section(
+                section_name, section_data.content, agents, command_dirs
+            )
+
+    # Generate root documentation (CLAUDE.md, GEMINI.md, etc.)
+    for agent_name, agent_inst in agent_instances.items():
+        agent_inst.generate_root_doc(
+            general,
+            rules_sections,
+            command_sections,
+            working_dir,
+        )
 
     # Build log message and user output based on processed agents
     log_data = {"agent": agent}
@@ -318,3 +249,20 @@ alwaysApply: true
     else:
         success_msg = f"Created files in {', '.join(created_dirs)} directories"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+
+
+def explode_main(
+    input_file: Annotated[
+        str, typer.Argument(help="Input markdown file")
+    ] = "instructions.md",
+    agent: Annotated[
+        str,
+        typer.Option(
+            "--agent",
+            "-a",
+            help="Agent to explode for (cursor, github, claude, gemini, or all)",
+        ),
+    ] = "all",
+) -> None:
+    """Convert instruction file to separate rule files."""
+    explode_implementation(input_file, agent, Path.cwd())

{llm_ide_rules-0.6.0 → llm_ide_rules-0.7.0}/src/llm_ide_rules/commands/implode.py

@@ -6,7 +6,6 @@ from typing_extensions import Annotated
 import typer
 
 from llm_ide_rules.agents import get_agent
-from llm_ide_rules.constants import load_section_globs
 from llm_ide_rules.log import log
 
 
@@ -14,14 +13,9 @@ def cursor(
     output: Annotated[
         str, typer.Argument(help="Output file for rules")
     ] = "instructions.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
 ) -> None:
     """Bundle Cursor rules into instructions.md and commands into commands.md."""
 
-    section_globs = load_section_globs(config)
     agent = get_agent("cursor")
     cwd = Path.cwd()
 
@@ -34,7 +28,6 @@ def cursor(
         "bundling cursor rules and commands",
         rules_dir=rules_dir,
         commands_dir=agent.commands_dir,
-        config=config,
     )
 
     rules_path = cwd / rules_dir
@@ -45,7 +38,7 @@ def cursor(
         raise typer.Exit(1)
 
     output_path = cwd / output
-    rules_written = agent.bundle_rules(output_path, section_globs)
+    rules_written = agent.bundle_rules(output_path)
     if rules_written:
         success_msg = f"Bundled cursor rules into {output}"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -54,7 +47,7 @@ def cursor(
         log.info("no cursor rules to bundle")
 
     commands_output_path = cwd / "commands.md"
-    commands_written = agent.bundle_commands(commands_output_path, section_globs)
+    commands_written = agent.bundle_commands(commands_output_path)
     if commands_written:
         success_msg = "Bundled cursor commands into commands.md"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -66,14 +59,9 @@ def github(
     output: Annotated[
         str, typer.Argument(help="Output file for instructions")
     ] = "instructions.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
 ) -> None:
     """Bundle GitHub instructions into instructions.md and prompts into commands.md."""
 
-    section_globs = load_section_globs(config)
     agent = get_agent("github")
     cwd = Path.cwd()
 
@@ -86,7 +74,6 @@ def github(
         "bundling github instructions and prompts",
         instructions_dir=rules_dir,
         prompts_dir=agent.commands_dir,
-        config=config,
     )
 
     rules_path = cwd / rules_dir
@@ -99,7 +86,7 @@ def github(
         raise typer.Exit(1)
 
     output_path = cwd / output
-    instructions_written = agent.bundle_rules(output_path, section_globs)
+    instructions_written = agent.bundle_rules(output_path)
     if instructions_written:
         success_msg = f"Bundled github instructions into {output}"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -108,7 +95,7 @@ def github(
         log.info("no github instructions to bundle")
 
     commands_output_path = cwd / "commands.md"
-    prompts_written = agent.bundle_commands(commands_output_path, section_globs)
+    prompts_written = agent.bundle_commands(commands_output_path)
     if prompts_written:
         success_msg = "Bundled github prompts into commands.md"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -118,14 +105,9 @@ def github(
 
 def claude(
     output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
 ) -> None:
     """Bundle Claude Code commands into commands.md."""
 
-    section_globs = load_section_globs(config)
     agent = get_agent("claude")
     cwd = Path.cwd()
 
@@ -137,7 +119,6 @@ def claude(
     log.info(
         "bundling claude code commands",
         commands_dir=commands_dir,
-        config=config,
     )
 
     commands_path = cwd / commands_dir
@@ -150,7 +131,7 @@ def claude(
         raise typer.Exit(1)
 
     output_path = cwd / output
-    commands_written = agent.bundle_commands(output_path, section_globs)
+    commands_written = agent.bundle_commands(output_path)
     if commands_written:
         success_msg = f"Bundled claude commands into {output}"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -161,14 +142,9 @@ def claude(
 
 def gemini(
     output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
 ) -> None:
     """Bundle Gemini CLI commands into commands.md."""
 
-    section_globs = load_section_globs(config)
     agent = get_agent("gemini")
     cwd = Path.cwd()
 
@@ -180,7 +156,6 @@ def gemini(
     log.info(
         "bundling gemini cli commands",
         commands_dir=commands_dir,
-        config=config,
     )
 
     commands_path = cwd / commands_dir
@@ -193,7 +168,7 @@ def gemini(
         raise typer.Exit(1)
 
     output_path = cwd / output
-    commands_written = agent.bundle_commands(output_path, section_globs)
+    commands_written = agent.bundle_commands(output_path)
     if commands_written:
         success_msg = f"Bundled gemini commands into {output}"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
@@ -204,14 +179,9 @@ def gemini(
 
 def opencode(
     output: Annotated[str, typer.Argument(help="Output file")] = "commands.md",
-    config: Annotated[
-        str | None,
-        typer.Option("--config", "-c", help="Custom configuration file path"),
-    ] = None,
 ) -> None:
     """Bundle OpenCode commands into commands.md."""
 
-    section_globs = load_section_globs(config)
     agent = get_agent("opencode")
     cwd = Path.cwd()
 
@@ -223,7 +193,6 @@ def opencode(
     log.info(
         "bundling opencode commands",
         commands_dir=commands_dir,
-        config=config,
     )
 
     commands_path = cwd / commands_dir
@@ -236,7 +205,7 @@ def opencode(
         raise typer.Exit(1)
 
     output_path = cwd / output
-    commands_written = agent.bundle_commands(output_path, section_globs)
+    commands_written = agent.bundle_commands(output_path)
     if commands_written:
         success_msg = f"Bundled opencode commands into {output}"
         typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))

llm_ide_rules-0.7.0/src/llm_ide_rules/constants.py

@@ -0,0 +1,13 @@
+"""Shared constants for explode and implode functionality."""
+
+VALID_AGENTS = ["cursor", "github", "claude", "gemini", "opencode", "all"]
+
+
+def header_to_filename(header: str) -> str:
+    """Convert a section header to a filename."""
+    return header.lower().replace(" ", "-")
+
+
+def filename_to_header(filename: str) -> str:
+    """Convert a filename back to a section header."""
+    return filename.replace("-", " ").title()

llm_ide_rules-0.7.0/src/llm_ide_rules/markdown_parser.py

@@ -0,0 +1,108 @@
+"""Markdown parsing utilities using markdown-it-py."""
+
+from typing import NamedTuple
+
+from markdown_it import MarkdownIt
+
+
+class SectionData(NamedTuple):
+    """Data for a parsed section."""
+
+    content: list[str]
+    glob_pattern: str | None
+
+
+def extract_glob_directive(
+    content_lines: list[str],
+) -> tuple[list[str], str | None]:
+    """Extract glob directive from section content if present.
+
+    Checks the first non-empty line after the header for 'globs: PATTERN'.
+
+    Args:
+        content_lines: Lines including the header
+
+    Returns:
+        Tuple of (content_without_directive, glob_pattern)
+        - glob_pattern is None if no directive found (means alwaysApply)
+        - glob_pattern is "manual" for manual-only sections
+    """
+    if not content_lines:
+        return content_lines, None
+
+    header_idx = None
+    for i, line in enumerate(content_lines):
+        if line.startswith("## "):
+            header_idx = i
+            break
+
+    if header_idx is None:
+        return content_lines, None
+
+    for i in range(header_idx + 1, len(content_lines)):
+        line = content_lines[i].strip()
+        if not line:
+            continue
+
+        if line.lower().startswith("globs: "):
+            glob_value = line[7:].strip()
+            filtered_content = content_lines[:i] + content_lines[i + 1 :]
+            return filtered_content, glob_value
+
+        break
+
+    return content_lines, None
+
+
+def parse_sections(text: str) -> tuple[list[str], dict[str, SectionData]]:
+    """Parse markdown text into general section and named sections.
+
+    Returns:
+        Tuple of (general_lines, sections_dict) where:
+        - general_lines: Lines before the first H2 header
+        - sections_dict: Dict mapping section names to SectionData (content + glob_pattern)
+    """
+    md = MarkdownIt()
+    tokens = md.parse(text)
+    lines = text.splitlines(keepends=True)
+
+    # Find all H2 headers
+    section_starts = []
+    for i, token in enumerate(tokens):
+        if token.type == "heading_open" and token.tag == "h2":
+            # Get the content of the header
+            # The next token is usually inline, which contains the text
+            if i + 1 < len(tokens) and tokens[i + 1].type == "inline":
+                header_content = tokens[i + 1].content.strip()
+                # token.map contains [start_line, end_line] (0-based)
+                if token.map:
+                    start_line = token.map[0]
+                    section_starts.append((start_line, header_content))
+
+    if not section_starts:
+        return lines, {}
+
+    # Extract general content (everything before first H2)
+    first_section_start = section_starts[0][0]
+    general_lines = lines[:first_section_start]
+
+    # Extract named sections
+    sections = {}
+    for i, (start_line, header_name) in enumerate(section_starts):
+        # End line is the start of the next section, or end of file
+        if i + 1 < len(section_starts):
+            end_line = section_starts[i + 1][0]
+        else:
+            end_line = len(lines)
+
+        # Extract all lines for this section
+        section_content = lines[start_line:end_line]
+
+        # Extract glob directive if present
+        filtered_content, glob_pattern = extract_glob_directive(section_content)
+
+        sections[header_name] = SectionData(
+            content=filtered_content, glob_pattern=glob_pattern
+        )
+
+    return general_lines, sections

llm_ide_rules-0.6.0/src/llm_ide_rules/constants.py

@@ -1,39 +0,0 @@
-"""Shared constants for explode and implode functionality."""
-
-import json
-from pathlib import Path
-
-VALID_AGENTS = ["cursor", "github", "claude", "gemini", "opencode", "all"]
-
-
-def load_section_globs(custom_config_path: str | None = None) -> dict[str, str | None]:
-    """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 Path(custom_config_path).exists():
-        config_path = Path(custom_config_path)
-    else:
-        config_path = Path(__file__).parent / "sections.json"
-
-    config = json.loads(config_path.read_text())
-
-    return config["section_globs"]
-
-
-# Default section globs - loaded from bundled JSON
-SECTION_GLOBS = load_section_globs()
-
-
-def header_to_filename(header: str) -> str:
-    """Convert a section header to a filename."""
-    return header.lower().replace(" ", "-")
-
-
-def filename_to_header(filename: str) -> str:
-    """Convert a filename back to a section header."""
-    return filename.replace("-", " ").title()

llm_ide_rules-0.6.0/src/llm_ide_rules/sections.json

@@ -1,17 +0,0 @@
-{
-  "section_globs": {
-    "Python": "**/*.py,pyproject.toml",
-    "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",
-    "Shell": "**/*.sh",
-    "TypeScript": "**/*.ts,**/*.tsx",
-    "Secrets": "env/*.sh,.envrc",
-    "Stripe Backend": "manual"
-  }
-}