rpr-cli 0.1.1__py3-none-any.whl

rpr/checks/workspace.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+import tomllib
+from pathlib import Path
+
+from rpr.checks.base import CheckResult
+
+
+def check_workspace(project_dir: Path) -> list[CheckResult]:
+    results: list[CheckResult] = []
+
+    # NX workspace
+    nx_json = project_dir / "nx.json"
+    nx_data: dict[str, object] = {}
+    nx_ok = False
+    nx_cloud_disabled = False
+    if nx_json.exists():
+        try:
+            nx_data = json.loads(nx_json.read_text())
+            nx_ok = True
+            nx_cloud_disabled = nx_data.get("neverConnectToCloud") is True
+        except (OSError, json.JSONDecodeError):
+            nx_ok = False
+
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="NX workspace",
+            status=nx_ok,
+            path=str(nx_json) if nx_ok else "nx.json missing",
+            suggestion="rpr init <name>",
+        )
+    )
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="NX Cloud disabled",
+            status=nx_cloud_disabled,
+            path=str(nx_json)
+            if nx_cloud_disabled
+            else "nx.json missing neverConnectToCloud=true",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    # UV workspace
+    pyproject = project_dir / "pyproject.toml"
+    pyproject_data: dict[str, object] = {}
+    uv_ok = False
+    if pyproject.exists():
+        try:
+            pyproject_data = tomllib.loads(pyproject.read_text())
+            tool = pyproject_data.get("tool", {})
+            uv_ok = "uv" in tool and "workspace" in tool["uv"]
+        except (OSError, tomllib.TOMLDecodeError):
+            uv_ok = False
+
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="UV workspace",
+            status=uv_ok,
+            path=str(pyproject)
+            if uv_ok
+            else "pyproject.toml with [tool.uv.workspace] missing",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    tool = pyproject_data.get("tool", {}) if pyproject_data else {}
+    uv_require_version = False
+    pytest_config = False
+    dev_dependencies_ok = False
+    if tool:
+        uv_require_version = "require-version" in tool.get("uv", {})
+        pytest_config = "pytest" in tool and "ini_options" in tool["pytest"]
+
+    dependency_groups = pyproject_data.get("dependency-groups", {}) if pyproject_data else {}
+    dev_dependencies = dependency_groups.get("dev", []) if isinstance(dependency_groups, dict) else []
+    if isinstance(dev_dependencies, list):
+        required = {
+            "pytest",
+            "pytest-asyncio",
+            "pytest-cov",
+            "ipykernel",
+            "pre-commit",
+            "pyright",
+            "ruff",
+            "maturin",
+        }
+        dev_dependencies_ok = required.issubset(set(dev_dependencies))
+
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="Root Python tooling",
+            status=uv_require_version and pytest_config and dev_dependencies_ok,
+            path=str(pyproject)
+            if uv_require_version and pytest_config and dev_dependencies_ok
+            else "pyproject.toml missing guide-aligned UV/Python sections",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    package_json = project_dir / "package.json"
+    node_workspace_ok = False
+    if package_json.exists():
+        try:
+            package_data = json.loads(package_json.read_text())
+            workspaces = package_data.get("workspaces", [])
+            node_workspace_ok = isinstance(workspaces, list) and {
+                "apps/*",
+                "packages/node/*",
+            }.issubset(set(workspaces))
+        except (OSError, json.JSONDecodeError):
+            node_workspace_ok = False
+
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="Node workspace",
+            status=node_workspace_ok,
+            path=str(package_json)
+            if node_workspace_ok
+            else "package.json missing npm workspaces",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    pre_commit = project_dir / ".pre-commit-config.yaml"
+    pre_commit_ok = False
+    if pre_commit.exists():
+        content = pre_commit.read_text()
+        pre_commit_ok = all(
+            needle in content
+            for needle in (
+                "pre-commit-hooks",
+                "nbstripout",
+                "uv run ruff format",
+                "uv run ruff check --fix",
+                "npx nx run-many --target=lint --all --fix --exclude=engine",
+            )
+        )
+
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area="Pre-commit config",
+            status=pre_commit_ok,
+            path=str(pre_commit)
+            if pre_commit_ok
+            else ".pre-commit-config.yaml missing guide-aligned hooks",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    # .rpr.yaml
+    rpr_yaml = project_dir / ".rpr.yaml"
+    results.append(
+        CheckResult(
+            group="Workspace",
+            area=".rpr.yaml config",
+            status=rpr_yaml.exists(),
+            path=str(rpr_yaml) if rpr_yaml.exists() else ".rpr.yaml missing",
+            suggestion="rpr init <name>",
+        )
+    )
+
+    return results

rpr/cli.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rpr import __version__
+from rpr.ui.console import console
+
+app = typer.Typer(
+    name="rpr",
+    help="RPR CLI -- React Python Rust monorepo scaffolding orchestrator.",
+    no_args_is_help=False,
+)
+
+# --- Command Imports (must be after app is defined) ---
+from rpr.commands import init as _init_mod  # noqa: E402, F401
+from rpr.commands import check as _check_mod  # noqa: E402, F401
+from rpr.commands import settings as _settings_mod  # noqa: E402, F401
+from rpr.commands import map as _map_mod  # noqa: E402, F401
+from rpr.commands import chat as _chat_mod  # noqa: E402, F401
+
+generate_app = typer.Typer(
+    name="generate",
+    help="Scaffold apps and packages (api, ui, domain, engine, storybook).",
+    no_args_is_help=True,
+)
+app.add_typer(generate_app, name="generate")
+
+sync_app = typer.Typer(
+    name="sync",
+    help="Sync AI instructions to Cursor, Copilot, and Claude Code.",
+    no_args_is_help=True,
+)
+app.add_typer(sync_app, name="sync")
+
+add_app = typer.Typer(
+    name="add",
+    help="Add code templates to the current project.",
+    no_args_is_help=True,
+)
+app.add_typer(add_app, name="add")
+
+# Import subcommands
+from rpr.commands.generate import domain as _domain_mod  # noqa: E402, F401
+from rpr.commands.generate import api as _api_mod  # noqa: E402, F401
+from rpr.commands.generate import ui as _ui_mod  # noqa: E402, F401
+from rpr.commands.generate import engine as _engine_mod  # noqa: E402, F401
+from rpr.commands.generate import storybook as _storybook_mod  # noqa: E402, F401
+from rpr.commands import sync as _sync_mod  # noqa: E402, F401
+from rpr.commands import add as _add_mod  # noqa: E402, F401
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"rpr {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-v",
+            help="Show the version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = False,
+) -> None:
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(_chat_mod.chat)
+
+
+if __name__ == "__main__":
+    app()

rpr/commands/add.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from rpr.cli import add_app
+from rpr.context import RunContext
+from rpr.generators.base import SyncConfig, interpolate
+from rpr.templates.registry import TEMPLATES
+from rpr.workspace import derive_variables
+
+console = Console()
+
+
+def _extract_code_blocks(markdown: str, language: str) -> list[str]:
+    """Extract fenced code blocks from markdown matching the given language."""
+    pattern = rf"```{language}\s*\n(.*?)```"
+    matches = re.findall(pattern, markdown, re.DOTALL)
+    if not matches:
+        pattern = r"```\w*\s*\n(.*?)```"
+        matches = re.findall(pattern, markdown, re.DOTALL)
+    return matches
+
+
+@add_app.command("template")
+def template(
+    template_id: Annotated[
+        str | None,
+        typer.Argument(help="Template ID to add (e.g., mapper_util, dto_util)."),
+    ] = None,
+    list_templates: Annotated[
+        bool, typer.Option("--list", "-l", help="List all available templates.")
+    ] = False,
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force", "-f", help="Overwrite existing files without prompting."
+        ),
+    ] = False,
+    name: Annotated[
+        str | None,
+        typer.Option("--name", "-n", help="App name for variable interpolation."),
+    ] = None,
+    source: Annotated[
+        str | None,
+        typer.Option("--source", "-s", help="Path to the rules source directory."),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview changes without writing.")
+    ] = False,
+) -> None:
+    """Add a code template file to the current project."""
+    ctx = RunContext(dry_run=dry_run, project_dir=Path.cwd())
+    config_path = ctx.project_dir / ".rpr.yaml"
+    config = SyncConfig.load(config_path)
+
+    if name:
+        variables = derive_variables(name)
+    elif config.variables:
+        variables = config.variables
+    else:
+        # For list command, we don't necessarily want to prompt
+        if list_templates:
+            variables = {}
+        else:
+            project_name = typer.prompt("Project name", default=ctx.project_dir.name)
+            variables = derive_variables(project_name)
+
+    if list_templates:
+        console.print("\n[bold]Available templates:[/]\n")
+        for tid, entry in TEMPLATES.items():
+            console.print(f"  [bold cyan]{tid:<20}[/] {entry.description}")
+            path_str = entry.target_path
+            if variables:
+                path_str = interpolate(path_str, variables)
+            console.print(f"  {'':20} -> {path_str}")
+        console.print()
+        raise typer.Exit(0)
+
+    if not template_id:
+        template_id = typer.prompt("Template ID")
+
+    if template_id not in TEMPLATES:
+        console.print(f"[bold red]Error:[/] Unknown template: {template_id}")
+        console.print("Run 'rpr add template --list' to see available templates.")
+        raise typer.Exit(1)
+
+    entry = TEMPLATES[template_id]
+
+    source_dir = (
+        Path(source).expanduser().resolve() if source else _find_source_dir(config)
+    )
+    if not source_dir:
+        console.print(
+            "[bold red]Error:[/] Cannot find rules source. Use --source or create .rpr.yaml"
+        )
+        raise typer.Exit(1)
+
+    source_file = source_dir / entry.source_subdir / entry.source_filename
+    if not source_file.exists():
+        console.print(f"[bold red]Error:[/] Source file not found: {source_file}")
+        raise typer.Exit(1)
+
+    markdown = source_file.read_text()
+
+    lang_hint = "python" if entry.language == "python" else "ts"
+    code_blocks = _extract_code_blocks(markdown, lang_hint)
+
+    if not code_blocks:
+        console.print(f"[bold red]Error:[/] No code blocks found in {source_file}")
+        raise typer.Exit(1)
+
+    code = code_blocks[0].strip() + "\n"
+
+    # Robust interpolation
+    code = interpolate(code, variables)
+    # Legacy support for older templates that might use these placeholders
+    name_val = variables.get("name", "")
+    name_underscore_val = variables.get("name_underscore", "")
+    code = code.replace("your_app_domain", f"{name_underscore_val}_domain")
+    code = code.replace("your-app-domain", f"{name_val}-domain")
+    code = code.replace("my_app_domain", f"{name_underscore_val}_domain")
+    code = code.replace("my-app-domain", f"{name_val}-domain")
+
+    target_path_str = interpolate(entry.target_path, variables)
+    target_path = ctx.project_dir / target_path_str
+
+    if not dry_run and target_path.exists() and not force:
+        console.print(f"[bold yellow]Warning:[/] File already exists: {target_path}")
+        overwrite = typer.confirm("Overwrite?")
+        if not overwrite:
+            console.print("Skipped.")
+            raise typer.Exit(0)
+
+    console.print(f"\n[bold]Adding template:[/] {template_id}\n")
+    ctx.write_file(target_path, code)
+
+    console.print(f"\n[bold green]Done![/] Template written to {target_path}")
+
+
+def _find_source_dir(config: SyncConfig) -> Path | None:
+    """Try to find the source directory from SyncConfig or common locations."""
+    if config.source:
+        p = Path(config.source).expanduser().resolve()
+        if p.exists():
+            # If the source points to 'instructions', we should look at its parent
+            # as templates are usually sibling directories to instructions.
+            if p.name == "instructions" and (p.parent / "special_files").exists():
+                return p.parent
+            return p
+
+    # Try relative to this file (development mode)
+    # src/rpr/commands/add.py -> parent x 2 is src/rpr/ -> / scaffolds
+    scaffold_root = Path(__file__).resolve().parent.parent / "scaffolds"
+    if (scaffold_root / "special_files").exists():
+        return scaffold_root
+
+    common = Path.home() / "development" / "project-getting-started"
+    if common.exists():
+        return common
+
+    return None

rpr/commands/chat.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from rpr.agent.bootstrap import resolve_agent_client
+from rpr.agent.client import AgentClient
+from rpr.application.chat_service import ChatCommandService
+from rpr.cli import app
+from rpr.context import RunContext
+from rpr.ui.theme import settings_manager
+
+
+def _get_agent_client(provider: str | None, model: str | None) -> AgentClient:
+    return resolve_agent_client(provider, model)
+
+
+@app.command()
+def chat(
+    provider: Annotated[
+        str | None, typer.Option(help="Override the AI provider to use.")
+    ] = None,
+    model: Annotated[
+        str | None, typer.Option(help="Override the model to use.")
+    ] = None,
+    approval_mode: Annotated[
+        str | None,
+        typer.Option(
+            help="Override the approval mode for this session.", case_sensitive=False
+        ),
+    ] = None,
+) -> None:
+    """Start an interactive chat session with the AI agent."""
+    try:
+        asyncio.run(
+            ChatCommandService.instance().run(
+                provider=provider,
+                model=model,
+                approval_mode_override=approval_mode,
+                client_factory=_get_agent_client,
+                context_factory=RunContext,
+                settings=settings_manager,
+            )
+        )
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc

rpr/commands/check.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rpr.application.checks import collect_check_report, serialize_check_results
+from rpr.cli import app
+from rpr.ui.console import console
+from rpr.ui.renderers import render_heading, render_status_row
+
+
+@app.command()
+def check(
+    group: Annotated[
+        str | None,
+        typer.Option(
+            "--group",
+            help="Run only a specific group: workspace, instructions, packages.",
+        ),
+    ] = None,
+    as_json: Annotated[
+        bool, typer.Option("--json", help="Emit machine-readable JSON output.")
+    ] = False,
+) -> None:
+    """Inspect the current project and report setup status."""
+    project_dir = Path.cwd()
+    report = collect_check_report(project_dir, group=group)
+
+    if as_json:
+        typer.echo(json.dumps(serialize_check_results(report.results)))
+        if any(not result.status for result in report.results):
+            raise typer.Exit(1)
+        return
+
+    render_heading(f"rpr check — project: {report.project_name}")
+
+    current_group = None
+    for result in report.results:
+        if result.group != current_group:
+            current_group = result.group
+            console.print(f"[heading]{current_group}[/]")
+
+        icon_char = "✓" if result.status else "✗"
+        render_status_row(
+            icon_char, result.area, str(result.path), result.status, result.suggestion
+        )
+
+    console.print()
+
+    if any(not result.status for result in report.results):
+        raise typer.Exit(1)