rpr-cli 0.1.28__tar.gz → 0.1.30__tar.gz

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpr-cli
-Version: 0.1.28
+Version: 0.1.30
 Summary: RPR CLI -- React Python Rust monorepo scaffolding orchestrator
 License-Expression: MIT
 License-File: LICENSE
@@ -109,6 +109,7 @@ Sync project context to your favorite AI tools and add common code patterns.
 ```bash
 rpr sync rules                         # Sync AI instructions to Cursor, Copilot, Claude Code, and Gemini
 rpr add template python mapper_util    # Add a Python code template to your project
+rpr add template python camel_case_model
 rpr add template node sticky_navigation --include-tests
 rpr add template node -l               # List available Node/TSX templates
 rpr add template --list                # List all available code templates

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/README.md

@@ -94,6 +94,7 @@ Sync project context to your favorite AI tools and add common code patterns.
 ```bash
 rpr sync rules                         # Sync AI instructions to Cursor, Copilot, Claude Code, and Gemini
 rpr add template python mapper_util    # Add a Python code template to your project
+rpr add template python camel_case_model
 rpr add template node sticky_navigation --include-tests
 rpr add template node -l               # List available Node/TSX templates
 rpr add template --list                # List all available code templates

rpr_cli-0.1.30/src/rpr/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.30"

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/src/rpr/commands/generate/domain.py

@@ -17,7 +17,12 @@ console = Console()
 
 _SCAFFOLD_DIR = Path(__file__).parent.parent.parent / "scaffolds" / "domain"
 
-_UTILITY_TEMPLATES = ["mapper_util", "dto_util", "partial_update"]
+_UTILITY_TEMPLATES = [
+    "mapper_util",
+    "dto_util",
+    "camel_case_model",
+    "partial_update",
+]
 
 
 @generate_app.command()

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/src/rpr/context.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import shutil
 import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -53,7 +54,7 @@ def _uv_activation_env(
 ) -> dict[str, str]:
     effective_env = dict(env or {})
     venv_dir = project_dir / ".venv"
-    venv_bin = venv_dir / "bin"
+    venv_bin = venv_dir / ("Scripts" if os.name == "nt" else "bin")
     if venv_bin.exists():
         current_path = effective_env.get("PATH", os.environ.get("PATH", ""))
         effective_env["VIRTUAL_ENV"] = str(venv_dir)
@@ -61,6 +62,38 @@ def _uv_activation_env(
     return effective_env
 
 
+def _resolve_windows_command_shim(
+    cmd: list[str], env: dict[str, str] | None = None
+) -> list[str]:
+    if os.name != "nt" or not cmd:
+        return cmd
+
+    executable = cmd[0]
+    if Path(executable).suffix or any(
+        separator and separator in executable for separator in (os.sep, os.altsep)
+    ):
+        return cmd
+
+    resolved = shutil.which(executable, path=(env or os.environ).get("PATH"))
+    if resolved is None:
+        return cmd
+
+    return [resolved, *cmd[1:]]
+
+
+def _format_display_command(cmd: list[str], env: dict[str, str] | None = None) -> str:
+    display_cmd = " ".join(cmd)
+    if not env:
+        return display_cmd
+
+    if os.name == "nt":
+        env_prefix = "; ".join(f'$env:{key}="{value}"' for key, value in env.items())
+        return f"{env_prefix}; {display_cmd}"
+
+    env_prefix = " ".join(f"{key}={value}" for key, value in env.items())
+    return f"{env_prefix} {display_cmd}"
+
+
 @dataclass
 class RunContext:
     dry_run: bool = False
@@ -95,11 +128,7 @@ class RunContext:
         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}"
+        display_cmd = _format_display_command(cmd, env)
 
         if self.dry_run and not supports_dry_run:
             render_command_start(display_cmd, resolved_cwd, is_dry_run=True)
@@ -109,9 +138,7 @@ class RunContext:
             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}"
+            display_cmd = _format_display_command(effective_cmd, env)
 
         render_command_start(display_cmd, resolved_cwd, is_dry_run=False)
 
@@ -119,6 +146,7 @@ class RunContext:
         if env:
             effective_env = os.environ.copy()
             effective_env.update(env)
+        effective_cmd = _resolve_windows_command_shim(effective_cmd, effective_env)
         result = subprocess.run(
             effective_cmd,
             cwd=resolved_cwd,

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/src/rpr/scaffolds/instructions/domain.instructions.md

@@ -78,7 +78,7 @@ npx nx run {name_underscore}_domain:migrate -- downgrade -1
 - Reuse existing DTOs when the contract is the same. Do not create near-duplicate DTOs for every small variation.
 - DTOs exposed through the API should stay minimal and focused on the contract, not internal persistence details.
 - Mapper functions should live in the DTO or mapper layer and follow a clear `to_dto()` naming convention.
-- DTOs that are serialized to JSON should use the project's camelCase-aware base model.
+- DTOs that are serialized to JSON should inherit from `CamelCaseModel` in `utils/camel_case_model.py`.
 - DTOs that represent external-service payloads can use `TypedDict` when a Pydantic model would add unnecessary weight.
 - Internal data containers that are not serialized can use `@dataclass` when that is the simplest fit.
 

rpr_cli-0.1.30/src/rpr/scaffolds/special_files/camel_case_model.md

@@ -0,0 +1,60 @@
+## Camel Case Model Template
+
+Target path: `/packages/python/{name_underscore}_domain/src/{name_underscore}_domain/utils/camel_case_model.py`
+
+Use this base model for DTOs that should accept snake_case, camelCase, and PascalCase input while serializing JSON with camelCase field names.
+
+The first Python block is the generated file used by `rpr add template camel_case_model`.
+
+```python
+from pydantic import AliasChoices, AliasGenerator, BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel, to_pascal
+
+
+def validation_alias_generator(field_name: str) -> AliasChoices:
+    """
+    Generate validation aliases for camelCase, PascalCase, and snake_case field names.
+
+    Examples:
+        rules_checked -> accepts: rulesChecked, RulesChecked, rules_checked
+        user_id -> accepts: userId, UserId, user_id
+    """
+    return AliasChoices(to_camel(field_name), to_pascal(field_name), field_name)
+
+
+class CamelCaseModel(BaseModel):
+    """
+    Base model that accepts flexible input field names and serializes JSON as camelCase.
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            validation_alias=validation_alias_generator,
+            serialization_alias=to_camel,
+        ),
+        populate_by_name=True,
+        ser_json_timedelta="float",
+        validate_assignment=True,
+    )
+```
+
+## Usage
+
+```python
+from your_app_domain.utils.camel_case_model import CamelCaseModel
+
+
+class RuleCheckDTO(CamelCaseModel):
+    rules_checked: int
+    user_id: str
+
+
+dto = RuleCheckDTO(rulesChecked=3, UserId="user-1")
+payload = dto.model_dump(by_alias=True)
+```
+
+## What This Template Solves
+
+- API DTOs can accept payloads from clients that use snake_case, camelCase, or PascalCase.
+- JSON serialization remains consistent by using camelCase aliases.
+- Assignment validation stays enabled for DTO instances that are updated in code.

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/src/rpr/templates/registry.py

@@ -211,6 +211,12 @@ TEMPLATES: dict[str, TemplateEntry] = {
         source_filename="dto_util.md",
         target_path="packages/python/{name_underscore}_domain/src/{name_underscore}_domain/utils/dto_util.py",
     ),
+    "camel_case_model": python_template(
+        id="camel_case_model",
+        description="Pydantic BaseModel with camelCase JSON and flexible validation aliases",
+        source_filename="camel_case_model.md",
+        target_path="packages/python/{name_underscore}_domain/src/{name_underscore}_domain/utils/camel_case_model.py",
+    ),
     "partial_update": python_template(
         id="partial_update",
         description="apply_partial_update utility for PATCH endpoints",

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/stories/completed/02-rpr-generate-domain.md

@@ -74,8 +74,8 @@ The `project.json` must define at minimum `test` and `lint` targets. Use `uv run
 
 - The domain package name uses underscores in the Python import path (`{name_underscore}_domain`) and dashes in the directory and `pyproject.toml` name (`{name}-domain`).
 - Use `uv add` if stored dependencies need to be managed programmatically.
-- The utils folder is scaffolded empty; use `rpr add template mapper_util`, `rpr add template dto_util`, `rpr add template partial_update`, or `rpr add template encrypted_column` to add those utilities.
-- After scaffolding, offer to run `rpr add template` for the most common utilities (mapper_util, dto_util, partial_update).
+- The utils folder is scaffolded empty; use `rpr add template mapper_util`, `rpr add template dto_util`, `rpr add template camel_case_model`, `rpr add template partial_update`, or `rpr add template encrypted_column` to add those utilities.
+- After scaffolding, offer to run `rpr add template` for the most common utilities (mapper_util, dto_util, camel_case_model, partial_update).
 - `config/settings.py` and `config/container.py` are generated from `src/rpr/scaffolds/domain/settings.md` and `container.md` (bundled templates that mirror `special_files/domain_settings.md` and `special_files/domain_container.md`). They can be reset at any time via `rpr add template domain_settings` or `rpr add template domain_container`.
 - If the domain Container ever needs lifecycle hooks (startup/shutdown), see the lifecycle extension pattern documented in Story 10.
 

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/stories/completed/08-rpr-add-template.md

@@ -25,6 +25,7 @@ Neither `rpr init` nor `rpr generate ui` add these files directly — they deleg
 | `domain_container`  | `special_files/domain_container.md`     | `packages/python/domain/src/<name>_domain/config/container.py`                                |
 | `mapper_util`       | `special_files/mapper_util.md`          | Python domain package (e.g., `packages/python/domain/src/<name>_domain/utils/mapper_util.py`) |
 | `dto_util`          | `special_files/dto_util.md`             | Python domain package utils                                                                   |
+| `camel_case_model`  | `special_files/camel_case_model.md`     | Python domain package utils                                                                   |
 | `partial_update`    | `special_files/partial_update.md`       | Python domain package utils                                                                   |
 | `encrypted_column`  | `special_files/encrypted_column.md`     | Python domain package (models/config)                                                         |
 | `sticky_navigation` | `js_special_files/sticky-navigation.md` | `packages/node/<name>-ui/src/hooks/useStateNavigation.ts`                                     |

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/tests/test_add.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import importlib.util
 from pathlib import Path
 
+import pytest
 from typer.testing import CliRunner
 
 from rpr.cli import app
@@ -39,6 +41,7 @@ def test_add_template_list():
         assert "domain_settings" in result.stdout
         assert "domain_container" in result.stdout
         assert "mapper_util" in result.stdout
+        assert "camel_case_model" in result.stdout
         assert "sticky_navigation" in result.stdout
         assert "virtual_list" in result.stdout
         # Should show placeholders if no name/config
@@ -61,10 +64,12 @@ def test_add_template_list_by_language():
         assert "node fetch_service" in node_result.stdout
         assert "node virtual_list" in node_result.stdout
         assert "python mapper_util" not in node_result.stdout
+        assert "python camel_case_model" not in node_result.stdout
 
         python_result = runner.invoke(app, ["add", "template", "python", "--list"])
         assert python_result.exit_code == 0, python_result.stdout
         assert "python mapper_util" in python_result.stdout
+        assert "python camel_case_model" in python_result.stdout
         assert "python domain_settings" in python_result.stdout
         assert "node sticky_navigation" not in python_result.stdout
 
@@ -146,6 +151,76 @@ def test_add_domain_container_template_execution():
         assert "override __new__" in content
 
 
+def test_add_camel_case_model_template_execution():
+    with runner.isolated_filesystem():
+        project_dir = Path.cwd()
+        scaffolds_dir = _repo_scaffolds_dir()
+        _write_rpr_config(scaffolds_dir)
+
+        result = runner.invoke(app, ["add", "template", "camel_case_model", "--force"])
+        assert result.exit_code == 0, result.stdout
+
+        target_path = (
+            project_dir
+            / "packages/python/test_app_domain/src/test_app_domain/utils/camel_case_model.py"
+        )
+        assert target_path.exists()
+
+        content = target_path.read_text()
+        assert "class CamelCaseModel(BaseModel):" in content
+        assert (
+            "def validation_alias_generator(field_name: str) -> AliasChoices:"
+            in content
+        )
+        assert (
+            "AliasChoices(to_camel(field_name), to_pascal(field_name), field_name)"
+            in content
+        )
+        assert "serialization_alias=to_camel" in content
+        assert "populate_by_name=True" in content
+        assert "validate_assignment=True" in content
+
+
+def test_camel_case_model_accepts_common_alias_styles():
+    pytest.importorskip("pydantic")
+
+    with runner.isolated_filesystem():
+        project_dir = Path.cwd()
+        scaffolds_dir = _repo_scaffolds_dir()
+        _write_rpr_config(scaffolds_dir)
+
+        result = runner.invoke(app, ["add", "template", "camel_case_model", "--force"])
+        assert result.exit_code == 0, result.stdout
+
+        target_path = (
+            project_dir
+            / "packages/python/test_app_domain/src/test_app_domain/utils/camel_case_model.py"
+        )
+        module_spec = importlib.util.spec_from_file_location(
+            "camel_case_model", target_path
+        )
+        assert module_spec is not None
+        assert module_spec.loader is not None
+        module = importlib.util.module_from_spec(module_spec)
+        module_spec.loader.exec_module(module)
+
+        class RuleCheckDTO(module.CamelCaseModel):
+            rules_checked: int
+            user_id: str
+
+        camel_dto = RuleCheckDTO(rulesChecked=2, userId="user-1")
+        pascal_dto = RuleCheckDTO(RulesChecked=3, UserId="user-2")
+        snake_dto = RuleCheckDTO(rules_checked=4, user_id="user-3")
+
+        assert camel_dto.rules_checked == 2
+        assert pascal_dto.user_id == "user-2"
+        assert snake_dto.rules_checked == 4
+        assert snake_dto.model_dump(by_alias=True) == {
+            "rulesChecked": 4,
+            "userId": "user-3",
+        }
+
+
 def test_add_template_dry_run():
     with runner.isolated_filesystem():
         scaffolds_dir = _repo_scaffolds_dir()

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/tests/test_context.py

@@ -75,6 +75,37 @@ class TestRunCommandLive:
         _, kwargs = mock_run.call_args
         assert kwargs["env"]["NX_NO_CLOUD"] == "true"
 
+    def test_run_uv_command_uses_windows_venv_scripts_path(self, tmp_path):
+        scripts_dir = tmp_path / ".venv" / "Scripts"
+        scripts_dir.mkdir(parents=True)
+        ctx = make_ctx(dry_run=False, project_dir=tmp_path)
+        fake_result = completed(["uv", "sync"])
+
+        with (
+            patch("rpr.context.os.name", "nt"),
+            patch("rpr.context.shutil.which", return_value=None),
+            patch("subprocess.run", return_value=fake_result) as mock_run,
+        ):
+            ctx.run_uv_command(["uv", "sync"])
+
+        _, kwargs = mock_run.call_args
+        assert kwargs["env"]["VIRTUAL_ENV"] == str(tmp_path / ".venv")
+        assert kwargs["env"]["PATH"].startswith(str(scripts_dir))
+
+    def test_resolves_windows_command_shim_before_executing(self):
+        ctx = make_ctx(dry_run=False)
+        fake_result = completed(["npx", "nx", "init"])
+        with (
+            patch("rpr.context.os.name", "nt"),
+            patch("rpr.context.shutil.which", return_value=r"C:\\nodejs\\npx.cmd") as mock_which,
+            patch("subprocess.run", return_value=fake_result) as mock_run,
+        ):
+            ctx.run_command(["npx", "nx", "init"], env={"NX_NO_CLOUD": "true"})
+
+        args, _ = mock_run.call_args
+        assert args[0] == [r"C:\\nodejs\\npx.cmd", "nx", "init"]
+        mock_which.assert_called_once()
+
 
 # ---------------------------------------------------------------------------
 # run_command — dry-run mode, nested CLI does NOT support --dry-run
@@ -119,6 +150,17 @@ class TestRunCommandDryRunUnsupported:
         captured = capsys.readouterr().out
         assert "NX_NO_CLOUD=true npx nx init" in captured
 
+    def test_dry_run_shows_powershell_env_prefix_on_windows(self, capsys):
+        ctx = make_ctx(dry_run=True)
+        with (
+            patch("rpr.context.os.name", "nt"),
+            patch("rpr.ui.renderers.console", Console(highlight=False, no_color=True)),
+            patch("subprocess.run"),
+        ):
+            ctx.run_command(["npx", "nx", "init"], env={"NX_NO_CLOUD": "true"})
+        captured = capsys.readouterr().out
+        assert '$env:NX_NO_CLOUD="true"; npx nx init' in captured
+
 
 # ---------------------------------------------------------------------------
 # run_command — dry-run mode, nested CLI DOES support --dry-run

{rpr_cli-0.1.28 → rpr_cli-0.1.30}/tests/test_generate_domain.py

@@ -184,6 +184,43 @@ def test_generate_domain_with_migrations_scaffolds_alembic_and_target(monkeypatc
         ]
 
 
+def test_generate_domain_can_run_common_utility_templates(monkeypatch):
+    recorded_calls: list[tuple[list[str], Path | str | None]] = []
+
+    def fake_run_command(
+        self, cmd, *, cwd=None, env=None, capture=False, supports_dry_run=False
+    ):
+        recorded_calls.append((cmd, cwd))
+        return _completed(cmd)
+
+    monkeypatch.setattr("rpr.context.RunContext.run_command", fake_run_command)
+    monkeypatch.setattr(
+        "rpr.commands.generate.domain.typer.confirm", lambda *args, **kwargs: True
+    )
+
+    with runner.isolated_filesystem():
+        _write_root_pyproject()
+
+        result = runner.invoke(app, ["generate", "domain", "my-app"])
+        assert result.exit_code == 0, result.stdout
+
+        utility_commands = [cmd for cmd, _ in recorded_calls[2:]]
+        assert utility_commands == [
+            ["rpr", "add", "template", "python", "mapper_util", "--name", "my-app"],
+            ["rpr", "add", "template", "python", "dto_util", "--name", "my-app"],
+            [
+                "rpr",
+                "add",
+                "template",
+                "python",
+                "camel_case_model",
+                "--name",
+                "my-app",
+            ],
+            ["rpr", "add", "template", "python", "partial_update", "--name", "my-app"],
+        ]
+
+
 def test_generate_domain_dry_run_previews_config_files(monkeypatch, capsys):
     monkeypatch.setattr(
         "rpr.context.console", Console(highlight=False, no_color=True), raising=False

rpr_cli-0.1.28/src/rpr/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.28"