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

llm_ide_rules/commands/implode.py

@@ -1,218 +1,245 @@
 """Implode command: Bundle rule files into a single instruction file."""
 
-import os
 from pathlib import Path
 from typing_extensions import Annotated
-import logging
 
 import typer
-import structlog
-
-from llm_ide_rules.constants import load_section_globs, header_to_filename, filename_to_header
-
-logger = structlog.get_logger()
-
-
-def get_ordered_files(file_list, section_globs_keys):
-    """Order files based on SECTION_GLOBS key order, with unmapped files at the end."""
-    file_dict = {f.stem: f for f in file_list}
-    ordered_files = []
-
-    # Add files in SECTION_GLOBS order
-    for section_name in section_globs_keys:
-        filename = header_to_filename(section_name)
-        if filename in file_dict:
-            ordered_files.append(file_dict[filename])
-            del file_dict[filename]
-
-    # Add any remaining files (not in SECTION_GLOBS) sorted alphabetically
-    remaining_files = sorted(file_dict.values(), key=lambda p: p.name)
-    ordered_files.extend(remaining_files)
-
-    return ordered_files
-
-
-def get_ordered_files_github(file_list, section_globs_keys):
-    """Order GitHub instruction files based on SECTION_GLOBS key order, with unmapped files at the end.
-    Handles .instructions suffix by stripping it for ordering purposes."""
-    # Create dict mapping base filename (without .instructions) to the actual file
-    file_dict = {}
-    for f in file_list:
-        base_stem = f.stem.replace(".instructions", "")
-        file_dict[base_stem] = f
-
-    ordered_files = []
-
-    # Add files in SECTION_GLOBS order
-    for section_name in section_globs_keys:
-        filename = header_to_filename(section_name)
-        if filename in file_dict:
-            ordered_files.append(file_dict[filename])
-            del file_dict[filename]
-
-    # Add any remaining files (not in SECTION_GLOBS) sorted alphabetically
-    remaining_files = sorted(file_dict.values(), key=lambda p: p.name)
-    ordered_files.extend(remaining_files)
-
-    return ordered_files
-
-
-def bundle_cursor_rules(rules_dir, output_file, section_globs):
-    """Bundle Cursor rule files into a single file."""
-    rule_files = list(Path(rules_dir).glob("*.mdc"))
-    general = [f for f in rule_files if f.stem == "general"]
-    others = [f for f in rule_files if f.stem != "general"]
-
-    # Order the non-general files based on section_globs
-    ordered_others = get_ordered_files(others, section_globs.keys())
-    ordered = general + ordered_others
-
-    def resolve_header_from_stem(stem):
-        """Return the canonical header for a given filename stem.
-
-        Prefer exact header names from section_globs (preserves acronyms like FastAPI, TypeScript).
-        Fallback to title-casing the filename when not found in section_globs.
-        """
-        for section_name in section_globs.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        for rule_file in ordered:
-            with open(rule_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                content = strip_yaml_frontmatter(content)
-                content = strip_header(content)
-                # Use canonical header names from SECTION_GLOBS when available
-                header = resolve_header_from_stem(rule_file.stem)
-                if rule_file.stem != "general":
-                    out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
-
-
-def strip_yaml_frontmatter(text):
-    """Strip YAML frontmatter from text."""
-    lines = text.splitlines()
-    if lines and lines[0].strip() == "---":
-        # Find the next '---' after the first
-        for i in range(1, len(lines)):
-            if lines[i].strip() == "---":
-                return "\n".join(lines[i + 1 :]).lstrip("\n")
-    return text
-
-
-def strip_header(text):
-    """Remove the first markdown header (## Header) from text if present."""
-    lines = text.splitlines()
-    if lines and lines[0].startswith("## "):
-        # Remove the header line and any immediately following empty lines
-        remaining_lines = lines[1:]
-        while remaining_lines and not remaining_lines[0].strip():
-            remaining_lines = remaining_lines[1:]
-        return "\n".join(remaining_lines)
-    return text
-
-
-def bundle_github_instructions(instructions_dir, output_file, section_globs):
-    """Bundle GitHub instruction files into a single file."""
-    copilot_general = Path(os.getcwd()) / ".github" / "copilot-instructions.md"
-    instr_files = list(Path(instructions_dir).glob("*.instructions.md"))
-
-    # Order the instruction files based on section_globs
-    # We need to create a modified version that strips .instructions from stems for ordering
-    ordered_files = get_ordered_files_github(instr_files, section_globs.keys())
-
-    def resolve_header_from_stem(stem):
-        """Return the canonical header for a given filename stem.
-
-        Prefer exact header names from section_globs (preserves acronyms like FastAPI, TypeScript).
-        Fallback to title-casing the filename when not found in section_globs.
-        """
-        for section_name in section_globs.keys():
-            if header_to_filename(section_name) == stem:
-                return section_name
-        return filename_to_header(stem)
-
-    with open(output_file, "w") as out:
-        # Write general copilot instructions if present
-        if copilot_general.exists():
-            content = copilot_general.read_text().strip()
-            if content:
-                out.write(content)
-                out.write("\n\n")
-        for instr_file in ordered_files:
-            with open(instr_file, "r") as f:
-                content = f.read().strip()
-                if not content:
-                    continue
-                content = strip_yaml_frontmatter(content)
-                content = strip_header(content)
-                # Use canonical header names from SECTION_GLOBS when available
-                base_stem = instr_file.stem.replace(".instructions", "")
-                header = resolve_header_from_stem(base_stem)
-                out.write(f"## {header}\n\n")
-                out.write(content)
-                out.write("\n\n")
+
+from llm_ide_rules.agents import get_agent
+from llm_ide_rules.constants import load_section_globs
+from llm_ide_rules.log import log
 
 
 def cursor(
-    output: Annotated[str, typer.Argument(help="Output file")] = "instructions.md",
-    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enable verbose logging")] = False,
-    config: Annotated[str, typer.Option("--config", "-c", help="Custom configuration file path")] = None,
-):
-    """Bundle Cursor rules into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
-    
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
-    
-    rules_dir = os.path.join(os.getcwd(), ".cursor", "rules")
-    output_path = os.path.join(os.getcwd(), output)
-    
-    logger.info("Bundling Cursor rules", rules_dir=rules_dir, output_file=output_path, config=config)
-    
-    if not Path(rules_dir).exists():
-        logger.error("Cursor rules directory not found", rules_dir=rules_dir)
+    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()
+
+    rules_dir = agent.rules_dir
+    if not rules_dir:
+        log.error("cursor rules directory not configured")
+        raise typer.Exit(1)
+
+    log.info(
+        "bundling cursor rules and commands",
+        rules_dir=rules_dir,
+        commands_dir=agent.commands_dir,
+        config=config,
+    )
+
+    rules_path = cwd / rules_dir
+    if not rules_path.exists():
+        log.error("cursor rules directory not found", rules_dir=str(rules_path))
+        error_msg = f"Cursor rules directory not found: {rules_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         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}")
+
+    output_path = cwd / output
+    rules_written = agent.bundle_rules(output_path, section_globs)
+    if rules_written:
+        success_msg = f"Bundled cursor rules into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no cursor rules to bundle")
+
+    commands_output_path = cwd / "commands.md"
+    commands_written = agent.bundle_commands(commands_output_path, section_globs)
+    if commands_written:
+        success_msg = "Bundled cursor commands into commands.md"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        commands_output_path.unlink(missing_ok=True)
 
 
 def github(
-    output: Annotated[str, typer.Argument(help="Output file")] = "instructions.md",
-    verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enable verbose logging")] = False,
-    config: Annotated[str, typer.Option("--config", "-c", help="Custom configuration file path")] = None,
-):
-    """Bundle GitHub/Copilot instructions into a single file."""
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
+    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()
+
+    rules_dir = agent.rules_dir
+    if not rules_dir:
+        log.error("github rules directory not configured")
+        raise typer.Exit(1)
+
+    log.info(
+        "bundling github instructions and prompts",
+        instructions_dir=rules_dir,
+        prompts_dir=agent.commands_dir,
+        config=config,
+    )
+
+    rules_path = cwd / rules_dir
+    if not rules_path.exists():
+        log.error(
+            "github instructions directory not found", instructions_dir=str(rules_path)
+        )
+        error_msg = f"GitHub instructions directory not found: {rules_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
+
+    output_path = cwd / output
+    instructions_written = agent.bundle_rules(output_path, section_globs)
+    if instructions_written:
+        success_msg = f"Bundled github instructions into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no github instructions to bundle")
+
+    commands_output_path = cwd / "commands.md"
+    prompts_written = agent.bundle_commands(commands_output_path, section_globs)
+    if prompts_written:
+        success_msg = "Bundled github prompts into commands.md"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        commands_output_path.unlink(missing_ok=True)
+
+
+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()
+
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("claude code commands directory not configured")
+        raise typer.Exit(1)
+
+    log.info(
+        "bundling claude code commands",
+        commands_dir=commands_dir,
+        config=config,
+    )
+
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "claude code commands directory not found", commands_dir=str(commands_path)
+        )
+        error_msg = f"Claude Code commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
+
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path, section_globs)
+    if commands_written:
+        success_msg = f"Bundled claude commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no claude commands to bundle")
+
+
+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()
+
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("gemini cli commands directory not configured")
+        raise typer.Exit(1)
+
+    log.info(
+        "bundling gemini cli commands",
+        commands_dir=commands_dir,
+        config=config,
+    )
+
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "gemini cli commands directory not found", commands_dir=str(commands_path)
+        )
+        error_msg = f"Gemini CLI commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
+        raise typer.Exit(1)
+
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path, section_globs)
+    if commands_written:
+        success_msg = f"Bundled gemini commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no gemini commands to bundle")
+
+
+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()
+
+    commands_dir = agent.commands_dir
+    if not commands_dir:
+        log.error("opencode commands directory not configured")
+        raise typer.Exit(1)
+
+    log.info(
+        "bundling opencode commands",
+        commands_dir=commands_dir,
+        config=config,
+    )
+
+    commands_path = cwd / commands_dir
+    if not commands_path.exists():
+        log.error(
+            "opencode commands directory not found", commands_dir=str(commands_path)
         )
-    
-    # Load section globs (with optional custom config)
-    SECTION_GLOBS = load_section_globs(config)
-    
-    instructions_dir = os.path.join(os.getcwd(), ".github", "instructions")
-    output_path = os.path.join(os.getcwd(), output)
-    
-    logger.info("Bundling GitHub instructions", instructions_dir=instructions_dir, output_file=output_path, config=config)
-    
-    if not Path(instructions_dir).exists():
-        logger.error("GitHub instructions directory not found", instructions_dir=instructions_dir)
+        error_msg = f"OpenCode commands directory not found: {commands_path}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         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}")
 
+    output_path = cwd / output
+    commands_written = agent.bundle_commands(output_path, section_globs)
+    if commands_written:
+        success_msg = f"Bundled opencode commands into {output}"
+        typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
+    else:
+        output_path.unlink(missing_ok=True)
+        log.info("no opencode commands to bundle")

llm_ide_rules/commands/mcp.py

@@ -0,0 +1,119 @@
+"""
+MCP configuration management commands.
+"""
+
+import json5
+import typer
+from pathlib import Path
+
+from llm_ide_rules.agents import get_agent, get_all_agents
+from llm_ide_rules.mcp import McpConfig
+from llm_ide_rules.log import log
+
+mcp_app = typer.Typer(help="MCP configuration management")
+
+
+@mcp_app.command()
+def explode(
+    input_file: str = typer.Argument("mcp.json", help="Input unified MCP config file"),
+    scope: str = typer.Option(
+        "project", "--scope", "-s", help="Scope: project, global, or both"
+    ),
+    agent: str = typer.Option(
+        "all",
+        "--agent",
+        "-a",
+        help="Agent: claude, cursor, gemini, opencode, copilot, or all",
+    ),
+) -> None:
+    """Convert unified mcp.json to platform-specific configs."""
+    input_path = Path(input_file)
+    if not input_path.exists():
+        log.error("input file not found", file=input_file)
+        raise typer.Exit(1)
+
+    config = McpConfig.model_validate(json5.loads(input_path.read_text()))
+
+    if agent == "all":
+        agents = get_all_agents()
+    else:
+        agents = [get_agent(agent)]
+
+    for ag in agents:
+        if not ag.mcp_project_path:
+            continue
+
+        mcp_project_path = ag.mcp_project_path
+
+        servers = {
+            name: ag.transform_mcp_server(s) for name, s in config.servers.items()
+        }
+
+        if scope in ("project", "both"):
+            project_path = Path.cwd() / mcp_project_path
+            ag.write_mcp_config(servers, project_path)
+            log.info("wrote project config", agent=ag.name, path=str(project_path))
+
+        if scope in ("global", "both") and ag.mcp_global_path:
+            global_path = Path.home() / ag.mcp_global_path
+            ag.write_mcp_config(servers, global_path)
+            log.info("wrote global config", agent=ag.name, path=str(global_path))
+
+
+@mcp_app.command()
+def implode(
+    output_file: str = typer.Argument(
+        "mcp.json", help="Output unified MCP config file"
+    ),
+    source: str = typer.Option(
+        None, "--source", help="Source agent to read from (e.g., claude, cursor)"
+    ),
+    scope: str = typer.Option(
+        "project", "--scope", "-s", help="Scope: project or global"
+    ),
+) -> None:
+    """Merge platform-specific MCP configs into unified mcp.json."""
+    if not source:
+        log.error("source agent must be specified")
+        raise typer.Exit(1)
+
+    ag = get_agent(source)
+
+    if scope == "project":
+        mcp_project_path = ag.mcp_project_path
+        if not mcp_project_path:
+            log.error("project config path not defined for agent", agent=source)
+            raise typer.Exit(1)
+        source_path = Path.cwd() / mcp_project_path
+    else:
+        mcp_global_path = ag.mcp_global_path
+        if not mcp_global_path:
+            log.error("global config path not defined for agent", agent=source)
+            raise typer.Exit(1)
+        source_path = Path.home() / mcp_global_path
+
+    if not source_path.exists():
+        log.error("source config not found", path=str(source_path))
+        raise typer.Exit(1)
+
+    server_configs = ag.read_mcp_config(source_path)
+    if not server_configs:
+        log.error("no MCP servers found in config", path=str(source_path))
+        raise typer.Exit(1)
+
+    servers = {
+        name: ag.reverse_transform_mcp_server(name, config)
+        for name, config in server_configs.items()
+    }
+
+    config = McpConfig(servers=servers)
+    output_path = Path(output_file)
+
+    import json
+
+    output_path.write_text(
+        json.dumps(
+            config.model_dump(exclude_none=True, exclude_defaults=True), indent=2
+        )
+    )
+    log.info("wrote unified config", path=str(output_path))

llm_ide_rules/constants.py

@@ -1,36 +1,39 @@
 """Shared constants for explode and implode functionality."""
 
 import json
-import os
 from pathlib import Path
 
-def load_section_globs(custom_config_path: str = None) -> dict:
+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 os.path.exists(custom_config_path):
+    if custom_config_path and Path(custom_config_path).exists():
         config_path = Path(custom_config_path)
     else:
-        # Load default bundled config
         config_path = Path(__file__).parent / "sections.json"
-    
-    with open(config_path, 'r') as f:
-        config = json.load(f)
-    
+
+    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):
+
+def header_to_filename(header: str) -> str:
     """Convert a section header to a filename."""
-    return header.lower().replace(' ', '-')
+    return header.lower().replace(" ", "-")
+
 
-def filename_to_header(filename):
+def filename_to_header(filename: str) -> str:
     """Convert a filename back to a section header."""
-    return filename.replace('-', ' ').title()
+    return filename.replace("-", " ").title()

llm_ide_rules/log.py

@@ -0,0 +1,9 @@
+"""Centralized logging configuration using structlog-config.
+
+This module configures structlog with opinionated defaults and exports a global logger.
+Import the `log` object from this module to use structured logging throughout the application.
+"""
+
+from structlog_config import configure_logger
+
+log = configure_logger()

llm_ide_rules/mcp/__init__.py

@@ -0,0 +1,7 @@
+"""
+MCP configuration management.
+"""
+
+from .models import McpConfig, McpServer
+
+__all__ = ["McpServer", "McpConfig"]

llm_ide_rules/mcp/models.py

@@ -0,0 +1,21 @@
+"""
+Pydantic models for unified MCP configuration.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class McpServer(BaseModel):
+    """Unified MCP server definition."""
+
+    command: str | None = None
+    args: list[str] = Field(default_factory=list)
+    url: str | None = None
+    type: str | None = None
+    env: dict[str, str] | None = None
+
+
+class McpConfig(BaseModel):
+    """Unified mcp.json format."""
+
+    servers: dict[str, McpServer]

llm_ide_rules/sections.json

@@ -1,6 +1,6 @@
 {
   "section_globs": {
-    "Python": "**/*.py",
+    "Python": "**/*.py,pyproject.toml",
     "Python App": "**/*.py",
     "Pytest Integration Tests": "tests/integration/**/*.py",
     "Pytest Tests": "tests/**/*.py",
@@ -9,10 +9,9 @@
     "FastAPI": "app/routes/**/*.py",
     "React": "**/*.tsx",
     "React Router": "web/app/routes/**/*.tsx",
-    "React Router Client Loader": null,
     "Shell": "**/*.sh",
     "TypeScript": "**/*.ts,**/*.tsx",
-    "TypeScript DocString": null,
-    "Secrets": null
+    "Secrets": "env/*.sh,.envrc",
+    "Stripe Backend": "manual"
   }
-}
+}