rpr-cli 0.1.1__py3-none-any.whl

rpr/commands/map.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from rpr.cli import app
+from rpr.map.architecture import assess_architecture
+from rpr.map.chains import build_diagnostic_chains, build_representative_chains
+from rpr.map.classifier import classify
+from rpr.map.coverage import build_coverage_map
+from rpr.map.dependencies import build_external_dependencies
+from rpr.map.extractor import analyze_project, build_raw_import_inventory
+from rpr.map.output import write_map
+from rpr.map.responsibility import build_responsibility_summaries
+from rpr.map.topology import build_directory_topology
+from rpr.ui.console import console
+
+
+@app.command()
+def map(
+    root: Annotated[
+        Path,
+        typer.Option("--root", help="Directory to analyze."),
+    ] = Path("."),
+    output: Annotated[
+        Path,
+        typer.Option("--output", help="Where to write the map.", dir_okay=False),
+    ] = Path("code-map.md"),
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview actions without writing files.")
+    ] = False,
+    details: Annotated[
+        bool,
+        typer.Option(
+            "--details", help="Show all files and individual node edges in the diagram."
+        ),
+    ] = False,
+    focus: Annotated[
+        str | None,
+        typer.Option("--focus", help="Repo-relative directory to drill down into."),
+    ] = None,
+) -> None:
+    """Generate a structured code map of a project."""
+    resolved_root = root.resolve()
+
+    if not resolved_root.exists() or not resolved_root.is_dir():
+        console.print(
+            f"[bold red]Error:[/] --root '{root}' does not exist or is not a directory."
+        )
+        raise typer.Exit(1)
+
+    if focus is not None:
+        focus = focus.replace("\\", "/").strip("/")
+
+    graph = analyze_project(resolved_root)
+    classified = classify(graph)
+    topology = build_directory_topology(graph, resolved_root)
+    assessment = assess_architecture(graph, topology)
+    chains = build_representative_chains(graph, topology, assessment)
+    diagnostic_chains = (
+        build_diagnostic_chains(graph, topology, assessment) if details else None
+    )
+
+    raw_imports = build_raw_import_inventory(graph)
+    ext_deps = build_external_dependencies(graph, raw_imports, topology)
+    responsibilities = build_responsibility_summaries(topology, classified, resolved_root)
+    coverage = build_coverage_map(graph, classified, topology)
+
+    if focus is not None and focus not in topology.nodes:
+        console.print(
+            f"[bold red]Error:[/] --focus '{focus}' is not a directory in the analyzed project."
+        )
+        raise typer.Exit(1)
+
+    if dry_run:
+        console.print(f"Root to scan : {resolved_root}", soft_wrap=True)
+        console.print(f"Output path  : {output}", soft_wrap=True)
+        write_map(
+            graph,
+            classified,
+            output,
+            resolved_root,
+            dry_run=True,
+            details=details,
+            topology=topology,
+            assessment=assessment,
+            chains=chains,
+            focus=focus,
+            diagnostic_chains=diagnostic_chains,
+            ext_deps=ext_deps,
+            responsibilities=responsibilities,
+            coverage=coverage,
+        )
+        console.print("No files written (dry-run mode).", soft_wrap=True)
+        raise typer.Exit(0)
+
+    write_map(
+        graph,
+        classified,
+        output,
+        resolved_root,
+        details=details,
+        topology=topology,
+        assessment=assessment,
+        chains=chains,
+        focus=focus,
+        diagnostic_chains=diagnostic_chains,
+        ext_deps=ext_deps,
+        responsibilities=responsibilities,
+        coverage=coverage,
+    )

rpr/commands/settings.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rpr.cli import app
+from rpr.ui.theme import SETTING_DEFINITIONS, THEMES, settings_manager, theme_manager
+from rpr.ui.console import console, refresh_console
+from rpr.ui.renderers import render_heading, render_info, render_success, render_table
+
+settings_app = typer.Typer(help="Manage RPR settings and themes.")
+app.add_typer(settings_app, name="settings")
+
+
+def _render_settings_overview() -> None:
+    rows = []
+    for definition, value in settings_manager.describe_settings():
+        choices = ", ".join(definition.choices) if definition.choices else "true, false"
+        rows.append([definition.key, value, choices, definition.description])
+    render_table("RPR Settings", ["Key", "Value", "Allowed", "Description"], rows)
+
+
+def _set_setting_value(key: str, value: str) -> None:
+    try:
+        settings_manager.set_value(key, value)
+    except KeyError:
+        console.print(f"[error]Error:[/] Unknown setting: {key}")
+        raise typer.Exit(1) from None
+    except ValueError as exc:
+        console.print(f"[error]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+
+    if key == "theme":
+        refresh_console()
+    render_success(
+        f"Updated [bold]{key}[/] to [bold]{settings_manager.get_value(key)}[/]"
+    )
+
+
+@settings_app.callback(invoke_without_command=True)
+def settings_root(ctx: typer.Context) -> None:
+    """Inspect persisted RPR settings."""
+    if ctx.invoked_subcommand is None:
+        _render_settings_overview()
+
+
+@settings_app.command("list")
+def list_settings() -> None:
+    """List all persisted settings."""
+    _render_settings_overview()
+
+
+@settings_app.command("get")
+def get_setting(
+    key: Annotated[str, typer.Argument(help="Setting key to inspect.")],
+) -> None:
+    """Read a single persisted setting."""
+    if key not in SETTING_DEFINITIONS:
+        console.print(f"[error]Error:[/] Unknown setting: {key}")
+        raise typer.Exit(1)
+    render_info(f"{key}: [bold]{settings_manager.get_value(key)}[/]")
+
+
+@settings_app.command("set")
+def set_setting(
+    key: Annotated[str, typer.Argument(help="Setting key to update.")],
+    value: Annotated[str, typer.Argument(help="New value for the setting.")],
+) -> None:
+    """Update a persisted setting."""
+    _set_setting_value(key, value)
+
+
+@settings_app.command("theme")
+def set_theme(
+    name: Annotated[
+        str | None, typer.Argument(help="The name of the theme to use.")
+    ] = None,
+    list_themes: Annotated[
+        bool, typer.Option("--list", "-l", help="List all available themes.")
+    ] = False,
+) -> None:
+    """Get or set the terminal UI theme."""
+    if list_themes:
+        render_heading("Available Themes")
+        current = theme_manager.current_theme_name
+        for theme_name in THEMES:
+            star = "[success]*[/success] " if theme_name == current else "  "
+            console.print(f"{star}{theme_name}")
+        return
+
+    if name is None:
+        render_info(f"Current theme: [bold]{theme_manager.current_theme_name}[/]")
+        return
+
+    try:
+        settings_manager.set_value("theme", name)
+    except ValueError as exc:
+        console.print(f"[error]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+
+    refresh_console()
+    render_success(f"Theme set to: [bold]{name}[/]")

rpr/commands/sync.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from rpr.cli import sync_app
+from rpr.context import RunContext
+from rpr.generators.base import SyncConfig, load_rules
+from rpr.generators.claude import generate_claude_rules
+from rpr.generators.copilot import generate_copilot_rules
+from rpr.generators.cursor import generate_cursor_rules
+from rpr.generators.gemini import generate_gemini_rules
+from rpr.workspace import derive_variables
+
+console = Console()
+
+TARGET_GENERATORS = {
+    "cursor": generate_cursor_rules,
+    "copilot": generate_copilot_rules,
+    "claude": generate_claude_rules,
+    "gemini": generate_gemini_rules,
+}
+
+
+@sync_app.command("rules")
+def rules(
+    target: Annotated[
+        str | None,
+        typer.Option(
+            "--target", "-t", help="Sync only one target: cursor, copilot, or claude."
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview changes without writing.")
+    ] = False,
+) -> None:
+    """Sync AI instructions to Cursor, Copilot, and Claude Code."""
+    ctx = RunContext(dry_run=dry_run, project_dir=Path.cwd())
+    config_path = ctx.project_dir / ".rpr.yaml"
+
+    config = SyncConfig.load(config_path)
+
+    if not config.source:
+        default_source = Path(__file__).parent.parent / "scaffolds" / "instructions"
+        if default_source.exists():
+            config.source = str(default_source)
+        else:
+            config.source = typer.prompt(
+                "Path to rules source directory",
+                default=str(default_source),
+            )
+            if not dry_run:
+                config.save(config_path)
+                console.print(f"[bold green]Saved:[/] {config_path}")
+
+    source_dir = Path(config.source).expanduser().resolve()
+    if not source_dir.exists():
+        console.print(f"[bold red]Error:[/] Source directory not found: {source_dir}")
+        raise typer.Exit(1)
+
+    if not config.variables:
+        console.print("[bold yellow]Warning:[/] No variables found in .rpr.yaml.")
+        project_name = typer.prompt("Project name", default=ctx.project_dir.name)
+        config.variables = derive_variables(project_name)
+        if not dry_run:
+            config.save(config_path)
+            console.print(f"[bold green]Updated variables in:[/] {config_path}")
+
+    all_rules = load_rules(source_dir)
+    if not all_rules:
+        # Fallback to source_dir if no "instructions" subdir exists
+        all_rules = load_rules(source_dir)
+
+    filtered = config.filter_rules(all_rules)
+
+    if not filtered:
+        console.print("[bold yellow]Warning:[/] No rules found matching the config.")
+        raise typer.Exit(0)
+
+    console.print(f"\n[bold]Syncing {len(filtered)} rules[/]\n")
+
+    targets = [target] if target else config.targets
+
+    for t in targets:
+        if t not in TARGET_GENERATORS:
+            console.print(
+                f"[bold red]Error:[/] Unknown target: {t}. Valid: cursor, copilot, claude, gemini"
+            )
+            continue
+
+        console.print(f"[bold]Target:[/] {t}")
+        TARGET_GENERATORS[t](filtered, ctx.project_dir, config.variables, ctx)
+
+    console.print(f"\n[bold green]Done![/] Rules synced for: {', '.join(targets)}")

rpr/context.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from rpr.ui.console import console
+from rpr.ui.markdown import DEFAULT_MARKDOWN_PREVIEW_LINES, render_markdown
+from rpr.ui.renderers import render_command_start, render_file_preview
+
+
+def _should_preview_markdown(path: Path, preview_markdown: bool) -> bool:
+    return preview_markdown and path.suffix.lower() in {".md", ".mdc"}
+
+
+def _render_markdown_file_preview(
+    path: Path,
+    content: str,
+    *,
+    is_dry_run: bool,
+    is_update: bool,
+    title: str | None,
+    max_lines: int | None,
+) -> None:
+    if is_dry_run:
+        action = "update" if is_update else "create"
+        console.print(
+            f"\n[dry_run][DRY RUN][/] Would {action}: [path]{path}[/]", soft_wrap=True
+        )
+
+    render_markdown(
+        content,
+        mode="preview",
+        title=title or path.name,
+        max_lines=max_lines,
+    )
+
+
+def _format_dependency_groups(
+    *, runtime: list[str] | None = None, dev: list[str] | None = None
+) -> str:
+    groups: list[str] = []
+    if runtime:
+        groups.append(f"runtime=[{', '.join(runtime)}]")
+    if dev:
+        groups.append(f"dev=[{', '.join(dev)}]")
+    return " ".join(groups)
+
+
+@dataclass
+class RunContext:
+    dry_run: bool = False
+    project_dir: Path = field(default_factory=Path.cwd)
+
+    def preview_dependencies(
+        self,
+        *,
+        manager: str,
+        target: Path | str,
+        runtime: list[str] | None = None,
+        dev: list[str] | None = None,
+    ) -> None:
+        scope = "Would install" if self.dry_run else "Installing"
+        groups = _format_dependency_groups(runtime=runtime, dev=dev)
+        message = f"{scope} {manager} dependencies for {target}"
+        if groups:
+            message = f"{message}: {groups}"
+        console.print(
+            f"[DRY RUN] {message}" if self.dry_run else message,
+            soft_wrap=True,
+            markup=False,
+        )
+
+    def run_command(
+        self,
+        cmd: list[str],
+        *,
+        cwd: Path | str | None = None,
+        env: dict[str, str] | None = None,
+        capture: bool = False,
+        supports_dry_run: bool = False,
+    ) -> subprocess.CompletedProcess[str]:
+        resolved_cwd = str(cwd) if cwd else str(self.project_dir)
+        env_prefix = " ".join(f"{key}={value}" for key, value in (env or {}).items())
+
+        display_cmd = " ".join(cmd)
+        if env_prefix:
+            display_cmd = f"{env_prefix} {display_cmd}"
+
+        if self.dry_run and not supports_dry_run:
+            render_command_start(display_cmd, resolved_cwd, is_dry_run=True)
+            return subprocess.CompletedProcess(cmd, 0, stdout="", stderr="")
+
+        effective_cmd = (
+            cmd + ["--dry-run"] if (self.dry_run and supports_dry_run) else cmd
+        )
+        if self.dry_run and supports_dry_run:
+            display_cmd = " ".join(effective_cmd)
+            if env_prefix:
+                display_cmd = f"{env_prefix} {display_cmd}"
+
+        render_command_start(display_cmd, resolved_cwd, is_dry_run=False)
+
+        effective_env = None
+        if env:
+            effective_env = os.environ.copy()
+            effective_env.update(env)
+        result = subprocess.run(
+            effective_cmd,
+            cwd=resolved_cwd,
+            env=effective_env,
+            capture_output=capture,
+            text=True,
+            check=True,
+        )
+        return result
+
+    def write_file(
+        self,
+        path: Path,
+        content: str,
+        *,
+        preview_markdown: bool = False,
+        markdown_title: str | None = None,
+        markdown_max_lines: int | None = DEFAULT_MARKDOWN_PREVIEW_LINES,
+    ) -> None:
+        if self.dry_run:
+            if _should_preview_markdown(path, preview_markdown):
+                _render_markdown_file_preview(
+                    path,
+                    content,
+                    is_dry_run=True,
+                    is_update=False,
+                    title=markdown_title,
+                    max_lines=markdown_max_lines,
+                )
+                return
+            render_file_preview(path, content, is_dry_run=True, is_update=False)
+            return
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        render_file_preview(path, content, is_dry_run=False, is_update=False)
+        if _should_preview_markdown(path, preview_markdown):
+            _render_markdown_file_preview(
+                path,
+                content,
+                is_dry_run=False,
+                is_update=False,
+                title=markdown_title,
+                max_lines=markdown_max_lines,
+            )
+
+    def ensure_dir(self, path: Path) -> None:
+        if self.dry_run:
+            from rpr.ui.console import console
+
+            console.print(
+                f"[dry_run][DRY RUN][/] Would create directory: [path]{path}[/]",
+                soft_wrap=True,
+            )
+            return
+
+        path.mkdir(parents=True, exist_ok=True)
+        from rpr.ui.console import console
+
+        console.print(f"[success]Created:[/] [path]{path}/[/]")
+
+    def update_file(
+        self,
+        path: Path,
+        content: str,
+        *,
+        preview_markdown: bool = False,
+        markdown_title: str | None = None,
+        markdown_max_lines: int | None = DEFAULT_MARKDOWN_PREVIEW_LINES,
+    ) -> None:
+        if self.dry_run:
+            if _should_preview_markdown(path, preview_markdown):
+                _render_markdown_file_preview(
+                    path,
+                    content,
+                    is_dry_run=True,
+                    is_update=True,
+                    title=markdown_title,
+                    max_lines=markdown_max_lines,
+                )
+                return
+            render_file_preview(path, content, is_dry_run=True, is_update=True)
+            return
+
+        path.write_text(content)
+        render_file_preview(path, content, is_dry_run=False, is_update=True)
+        if _should_preview_markdown(path, preview_markdown):
+            _render_markdown_file_preview(
+                path,
+                content,
+                is_dry_run=False,
+                is_update=True,
+                title=markdown_title,
+                max_lines=markdown_max_lines,
+            )

rpr/generators/base.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class Rule:
+    id: str
+    content: str
+    description: str = ""
+    apply_to: str = "**"
+    rule_type: str = "instruction"
+    language: str = "all"
+    source_path: Path | None = None
+
+
+def load_rules(source_dir: Path) -> list[Rule]:
+    """Load all markdown rules from a source directory, parsing YAML frontmatter."""
+    rules: list[Rule] = []
+
+    for md_file in sorted(source_dir.rglob("*.md")):
+        if ".venv" in md_file.parts:
+            continue
+
+        text = md_file.read_text()
+        rule_id = md_file.stem.replace(".instructions", "")
+        frontmatter: dict = {}
+        body = text
+
+        fm_match = re.match(r"^---\s*\n(.*?)\n---\s*\n(.*)$", text, re.DOTALL)
+        if fm_match:
+            try:
+                frontmatter = yaml.safe_load(fm_match.group(1)) or {}
+            except yaml.YAMLError:
+                frontmatter = {}
+            body = fm_match.group(2)
+
+        first_heading = ""
+        heading_match = re.search(r"^#+\s+(.+)$", body, re.MULTILINE)
+        if heading_match:
+            first_heading = heading_match.group(1).strip()
+
+        rules.append(
+            Rule(
+                id=rule_id,
+                content=body.strip(),
+                description=frontmatter.get("description", first_heading),
+                apply_to=frontmatter.get("applyTo", "**"),
+                rule_type=frontmatter.get("type", "instruction"),
+                language=frontmatter.get("language", "all"),
+                source_path=md_file,
+            )
+        )
+
+    return rules
+
+
+def interpolate(text: str, variables: dict[str, str]) -> str:
+    """Replace {variable} placeholders with values from the variables dict."""
+    if not variables:
+        return text
+    for key, value in variables.items():
+        text = text.replace(f"{{{key}}}", value)
+    return text
+
+
+@dataclass
+class SyncConfig:
+    source: str = ""
+    targets: list[str] = field(default_factory=lambda: ["cursor", "copilot", "claude"])
+    include: list[str] = field(default_factory=list)
+    exclude: list[str] = field(default_factory=list)
+    variables: dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls, path: Path) -> SyncConfig:
+        if not path.exists():
+            return cls()
+        try:
+            data = yaml.safe_load(path.read_text()) or {}
+        except yaml.YAMLError:
+            data = {}
+        return cls(
+            source=data.get("source", ""),
+            targets=data.get("targets", ["cursor", "copilot", "claude"]),
+            include=data.get("include", []),
+            exclude=data.get("exclude", []),
+            variables=data.get("variables", {}),
+        )
+
+    def save(self, path: Path) -> None:
+        data = {
+            "source": self.source,
+            "targets": self.targets,
+            "include": self.include,
+            "exclude": self.exclude,
+            "variables": self.variables,
+        }
+        path.write_text(yaml.dump(data, default_flow_style=False, sort_keys=False))
+
+    def filter_rules(self, rules: list[Rule]) -> list[Rule]:
+        if self.include:
+            rules = [r for r in rules if r.id in self.include]
+        if self.exclude:
+            rules = [r for r in rules if r.id not in self.exclude]
+        return rules

rpr/generators/claude.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from rpr.context import RunContext
+from rpr.generators.base import Rule, interpolate
+
+HEADER = "<!-- Generated by rpr sync -- do not edit manually -->\n\n"
+
+
+def generate_claude_rules(
+    rules: list[Rule],
+    project_dir: Path,
+    variables: dict[str, str],
+    ctx: RunContext,
+) -> None:
+    sections: list[str] = [HEADER.strip()]
+
+    for rule in rules:
+        content = interpolate(rule.content, variables)
+        section_header = (
+            f"## {rule.description}" if rule.description else f"## {rule.id}"
+        )
+        sections.append(f"{section_header}\n\n{content}")
+
+    full_content = "\n\n---\n\n".join(sections) + "\n"
+    ctx.write_file(
+        project_dir / "CLAUDE.md",
+        full_content,
+        preview_markdown=True,
+        markdown_title="Claude Instructions Preview",
+        markdown_max_lines=80,
+    )

rpr/generators/copilot.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from rpr.context import RunContext
+from rpr.generators.base import Rule, interpolate
+
+HEADER = "<!-- Generated by rpr sync -- do not edit manually -->\n\n"
+
+
+def generate_copilot_rules(
+    rules: list[Rule],
+    project_dir: Path,
+    variables: dict[str, str],
+    ctx: RunContext,
+) -> None:
+    instructions_dir = project_dir / ".github"
+    ctx.ensure_dir(instructions_dir)
+
+    global_rules = [r for r in rules if r.apply_to == "**"]
+
+    # Copilot custom instructions only support a single file.
+    # Scoped rules are ignored here as they don't map cleanly to a global context.
+
+    if global_rules:
+        global_content = HEADER
+        for rule in global_rules:
+            content = interpolate(rule.content, variables)
+            global_content += f"\n{content}\n\n---\n"
+        ctx.write_file(
+            instructions_dir / "copilot-instructions.md",
+            global_content,
+            preview_markdown=True,
+            markdown_title="Copilot Instructions Preview",
+            markdown_max_lines=80,
+        )