llm-ide-rules 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

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] = []
@@ -57,15 +57,21 @@ class GitHubAgent(BaseAgent):
                 content_parts.append("\n\n")
 
         for instr_file in ordered_instructions:
-            content = instr_file.read_text().strip()
-            if not content:
+            file_content = instr_file.read_text().strip()
+            if not file_content:
                 continue
 
-            content = strip_yaml_frontmatter(content)
+            apply_to_pattern = self._extract_apply_to_from_frontmatter(file_content)
+
+            content = strip_yaml_frontmatter(file_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")
+            if apply_to_pattern:
+                content_parts.append(f"globs: {apply_to_pattern}\n\n")
             content_parts.append(content)
             content_parts.append("\n\n")
 
@@ -75,8 +81,23 @@ class GitHubAgent(BaseAgent):
         output_file.write_text("".join(content_parts))
         return True
 
+    def _extract_apply_to_from_frontmatter(self, content: str) -> str | None:
+        """Extract applyTo pattern from YAML frontmatter."""
+        lines = content.splitlines()
+        if not lines or lines[0].strip() != "---":
+            return None
+
+        for i in range(1, len(lines)):
+            if lines[i].strip() == "---":
+                break
+            if lines[i].startswith("applyTo:"):
+                apply_to_value = lines[i][8:].strip().strip('"').strip("'")
+                return apply_to_value if apply_to_value else None
+
+        return None
+
     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 +122,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 +141,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")
@@ -136,6 +160,7 @@ class GitHubAgent(BaseAgent):
         filename: str,
         rules_dir: Path,
         glob_pattern: str | None = None,
+        description: str | None = None,
     ) -> None:
         """Write a GitHub instruction file (.instructions.md) with YAML frontmatter."""
         extension = self.rule_extension or ".instructions.md"
@@ -167,6 +192,7 @@ applyTo: "{glob_pattern}"
         )
 
         frontmatter = f"---\nmode: 'agent'\ndescription: '{description}'\n---\n"
+        filepath.parent.mkdir(parents=True, exist_ok=True)
         filepath.write_text(frontmatter + "".join(filtered_content))
 
     def write_general_instructions(
@@ -205,3 +231,13 @@ applyTo: "{glob_pattern}"
             args=config.get("args", []),
             env=config.get("env"),
         )
+
+    def configure_agents_md(self, base_dir: Path) -> bool:
+        """Configure VS Code to use AGENTS.md."""
+        from llm_ide_rules.utils import modify_json_file
+
+        settings_path = base_dir / ".vscode" / "settings.json"
+
+        updates = {"chat.useAgentsMdFile": True, "chat.useNestedAgentsMdFiles": True}
+
+        return modify_json_file(settings_path, updates)

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")
@@ -75,6 +79,7 @@ class OpenCodeAgent(BaseAgent):
         filename: str,
         rules_dir: Path,
         glob_pattern: str | None = None,
+        description: str | None = None,
     ) -> None:
         """OpenCode doesn't support rules."""
         pass
@@ -91,6 +96,7 @@ class OpenCodeAgent(BaseAgent):
         filepath = commands_dir / f"{filename}{extension}"
 
         trimmed = trim_content(content_lines)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
         filepath.write_text("".join(trimmed))
 
     def transform_mcp_server(self, server: McpServer) -> dict:
@@ -124,3 +130,7 @@ class OpenCodeAgent(BaseAgent):
             args=command_array[1:] if len(command_array) > 1 else [],
             env=config.get("environment"),
         )
+
+    def configure_agents_md(self, base_dir: Path) -> bool:
+        """OpenCode has native support, no configuration needed."""
+        return False

llm_ide_rules/agents/vscode.py

@@ -0,0 +1,88 @@
+"""VS Code agent implementation."""
+
+from pathlib import Path
+
+from llm_ide_rules.agents.base import BaseAgent
+from llm_ide_rules.mcp import McpServer
+
+
+class VSCodeAgent(BaseAgent):
+    """Agent for VS Code (native MCP support)."""
+
+    name = "vscode"
+    rules_dir = None  # VS Code typically uses .github (handled by GitHubAgent)
+    commands_dir = None
+    rule_extension = None
+    command_extension = None
+
+    mcp_global_path = None  # VS Code user settings are complex, focusing on workspace
+    mcp_project_path = ".vscode/mcp.json"
+    mcp_root_key = "servers"
+
+    def bundle_rules(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """VS Code doesn't support rules directly (uses GitHub Copilot)."""
+        return False
+
+    def bundle_commands(
+        self, output_file: Path, section_globs: dict[str, str | None] | None = None
+    ) -> bool:
+        """VS Code doesn't support commands directly."""
+        return False
+
+    def write_rule(
+        self,
+        content_lines: list[str],
+        filename: str,
+        rules_dir: Path,
+        glob_pattern: str | None = None,
+        description: str | None = None,
+    ) -> None:
+        """VS Code doesn't support rules."""
+        pass
+
+    def write_command(
+        self,
+        content_lines: list[str],
+        filename: str,
+        commands_dir: Path,
+        section_name: str | None = None,
+    ) -> None:
+        """VS Code doesn't support commands."""
+        pass
+
+    def transform_mcp_server(self, server: McpServer) -> dict:
+        """Transform unified server to VS Code format."""
+        # VS Code uses "env" key, similar to standard MCP
+        base = {}
+        if server.env:
+            base["env"] = server.env
+
+        if server.url:
+            # VS Code supports SSE via "url" (or "type": "sse"?)
+            # Research indicates basic MCP config in VS Code is similar to Claude
+            # but usually requires "command" for stdio.
+            # However, for remote/SSE, it might just need 'url'.
+            # Let's assume standard 'url' for now based on 'mcp.json' schema compatibility.
+            return {"url": server.url, **base}
+
+        return {
+            "command": server.command,
+            "args": server.args or [],
+            **base,
+        }
+
+    def reverse_transform_mcp_server(self, name: str, config: dict) -> McpServer:
+        """Transform VS Code config back to unified format."""
+        if "url" in config:
+            return McpServer(
+                url=config["url"],
+                env=config.get("env"),
+            )
+
+        return McpServer(
+            command=config["command"],
+            args=config.get("args", []),
+            env=config.get("env"),
+        )

llm_ide_rules/commands/config.py

@@ -0,0 +1,46 @@
+"""Command to configure agents to use AGENTS.md."""
+
+from pathlib import Path
+
+import typer
+from typing_extensions import Annotated
+
+from llm_ide_rules.agents import get_agent, get_all_agents
+
+
+def config_main(
+    agent: Annotated[
+        str | None,
+        typer.Option(help="Specific agent to configure (cursor, github, etc.)"),
+    ] = None,
+):
+    """
+    Configure agents to use AGENTS.md as their context source.
+    """
+    base_dir = Path.cwd()
+
+    agents_to_configure = []
+    if agent:
+        try:
+            agents_to_configure.append(get_agent(agent))
+        except ValueError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        agents_to_configure = get_all_agents()
+
+    for agent_inst in agents_to_configure:
+        if agent_inst.name == "agents":
+            continue
+
+        try:
+            configured = agent_inst.configure_agents_md(base_dir)
+            if configured:
+                typer.echo(
+                    typer.style(f"Configured {agent_inst.name}", fg=typer.colors.GREEN)
+                )
+            else:
+                msg = f"Skipped {agent_inst.name} (no changes needed or not applicable)"
+                typer.echo(typer.style(msg, fg=typer.colors.YELLOW))
+        except Exception as e:
+            typer.echo(f"Failed to configure {agent_inst.name}: {e}", err=True)

llm_ide_rules/commands/delete.py

@@ -7,7 +7,58 @@ import typer
 from typing_extensions import Annotated
 
 from llm_ide_rules.commands.download import INSTRUCTION_TYPES, DEFAULT_TYPES
+from llm_ide_rules.constants import header_to_filename
 from llm_ide_rules.log import log
+from llm_ide_rules.markdown_parser import parse_sections
+
+
+def get_generated_files(target_dir: Path) -> set[Path]:
+    """Identify files that would be generated from local instruction files."""
+    generated = set()
+
+    # Check instructions.md
+    instructions_path = target_dir / "instructions.md"
+    if instructions_path.exists():
+        try:
+            general, sections = parse_sections(instructions_path.read_text())
+
+            # If general instructions exist, these files are generated
+            if any(line.strip() for line in general):
+                generated.add(target_dir / ".cursor/rules/general.mdc")
+                generated.add(target_dir / ".github/copilot-instructions.md")
+                generated.add(target_dir / "CLAUDE.md")
+
+            # If any sections exist, root docs are definitely generated
+            if sections:
+                generated.add(target_dir / "CLAUDE.md")
+
+            # Section specific files
+            for header in sections:
+                filename = header_to_filename(header)
+                generated.add(target_dir / f".cursor/rules/{filename}.mdc")
+                generated.add(
+                    target_dir / f".github/instructions/{filename}.instructions.md"
+                )
+
+        except Exception as e:
+            log.warning("failed to parse instructions.md", error=str(e))
+
+    # Check commands.md
+    commands_path = target_dir / "commands.md"
+    if commands_path.exists():
+        try:
+            _, sections = parse_sections(commands_path.read_text())
+            for header in sections:
+                filename = header_to_filename(header)
+                generated.add(target_dir / f".cursor/commands/{filename}.md")
+                generated.add(target_dir / f".github/prompts/{filename}.prompt.md")
+                generated.add(target_dir / f".gemini/commands/{filename}.toml")
+                generated.add(target_dir / f".claude/commands/{filename}.md")
+                generated.add(target_dir / f".opencode/commands/{filename}.md")
+        except Exception as e:
+            log.warning("failed to parse commands.md", error=str(e))
+
+    return {p.resolve() for p in generated}
 
 
 def find_files_to_delete(
@@ -38,6 +89,11 @@ def find_files_to_delete(
             if file_path.exists() and file_path.is_file():
                 files_to_delete.append(file_path)
 
+        for file_name in config.get("generated_files", []):
+            file_path = target_dir / file_name
+            if file_path.exists() and file_path.is_file():
+                files_to_delete.append(file_path)
+
         for file_pattern in config.get("recursive_files", []):
             matching_files = list(target_dir.rglob(file_pattern))
             files_to_delete.extend([f for f in matching_files if f.is_file()])
@@ -49,12 +105,19 @@ def delete_main(
     instruction_types: Annotated[
         list[str] | None,
         typer.Argument(
-            help="Types of instructions to delete (cursor, github, gemini, claude, agent, agents). Deletes everything by default."
+            help="Types of instructions to delete (cursor, github, gemini, claude, opencode, agents). Deletes everything by default."
         ),
     ] = None,
     target_dir: Annotated[
         str, typer.Option("--target", "-t", help="Target directory to delete from")
     ] = ".",
+    everything: Annotated[
+        bool,
+        typer.Option(
+            "--everything",
+            help="Delete all instruction files, not just those generated from local sources.",
+        ),
+    ] = False,
     yes: Annotated[
         bool,
         typer.Option(
@@ -64,17 +127,25 @@ def delete_main(
 ):
     """Remove downloaded LLM instruction files.
 
-    This command removes files and directories that were downloaded by the 'download' command.
-    It will show you what will be deleted and ask for confirmation before proceeding.
+    This command removes files and directories that were downloaded by the 'download' command
+    or generated by the 'explode' command.
+
+    By default, it ONLY deletes files that correspond to your local 'instructions.md' and
+    'commands.md' files. This prevents accidental deletion of manually created files.
+    Use --everything to delete all standard instruction files and directories.
 
     Examples:
 
     \b
-    # Delete everything (with confirmation)
+    # Delete only generated files (safest, default)
     llm_ide_rules delete
 
     \b
-    # Delete only Cursor and Gemini files
+    # Delete ALL instruction files (including manual ones)
+    llm_ide_rules delete --everything
+
+    \b
+    # Delete only Cursor and Gemini files (but only if generated)
     llm_ide_rules delete cursor gemini
 
     \b
@@ -115,9 +186,39 @@ def delete_main(
         instruction_types, target_path
     )
 
+    skipped_files = []
+
+    if not everything:
+        log.info("filtering files to delete based on local sources")
+        generated_files = get_generated_files(target_path)
+
+        # Expand directories to files for granular filtering
+        expanded_files = []
+        for d in dirs_to_delete:
+            expanded_files.extend([f for f in d.rglob("*") if f.is_file()])
+
+        all_candidates = files_to_delete + expanded_files
+
+        # Filter: keep only files that are in the generated set
+        # We compare resolved paths to be safe
+        files_to_delete = [f for f in all_candidates if f.resolve() in generated_files]
+
+        # Identify skipped files (candidates that were NOT in generated set)
+        skipped_files = [
+            f for f in all_candidates if f.resolve() not in generated_files
+        ]
+
+        # We are no longer deleting whole directories in safe mode
+        dirs_to_delete = []
+
     if not dirs_to_delete and not files_to_delete:
         log.info("no files found to delete")
         typer.echo("No matching instruction files found to delete.")
+        if skipped_files:
+            typer.echo(
+                f"\n{len(skipped_files)} files were skipped because they don't match local instructions/commands."
+            )
+            typer.echo("Use --everything to delete them.")
         return
 
     typer.echo("\nThe following files and directories will be deleted:\n")
@@ -137,6 +238,11 @@ def delete_main(
     total_items = len(dirs_to_delete) + len(files_to_delete)
     typer.echo(f"\nTotal: {total_items} items")
 
+    if skipped_files:
+        typer.echo(
+            f"\n(Note: {len(skipped_files)} other files will be preserved. Use --everything to delete them)"
+        )
+
     if not yes:
         typer.echo()
         confirm = typer.confirm("Are you sure you want to delete these files?")