rpr-cli 0.2.0__tar.gz → 0.3.1__tar.gz

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpr-cli
-Version: 0.2.0
+Version: 0.3.1
 Summary: RPR CLI -- React Python Rust monorepo scaffolding orchestrator
 License-Expression: MIT
 License-File: LICENSE

{rpr_cli-0.2.0/src/rpr/scaffolds → rpr_cli-0.3.1/Sample-dot-github}/instructions/all.instructions.md

@@ -37,7 +37,7 @@ This project uses an NX + UV monorepo with a domain-driven design approach. Appl
 - Instruction files describe when to use a pattern and what constraints to follow.
 - `setup-guide.instructions.md` captures the NX + UV workspace contract for root setup, project layout, naming, and expected command surfaces.
 - `tooling.instructions.md` defines workspace-wide linting, formatting, and pre-commit conventions.
-- `tooling-setup.instructions.md` contains detailed setup guidance for root tooling files such as `pyproject.toml`, `nx.json`, `.pre-commit-config.yaml`, and `eslint.config.mjs`.
+- `tooling-setup.instructions.md` contains detailed setup guidance for root tooling files such as `pyproject.toml`, `nx.json`, `.pre-commit-config.yaml`, `.oxlintrc.json`, `.oxfmtrc.json`, and `.dependency-cruiser.cjs`.
 - Shared utility implementations should live in stable project paths so code can reuse them instead of duplicating the same helpers in multiple places.
 - Files in `.github/scaffolds/` are reference examples. Use them as guidance if they exist, but do not force the codebase to match them when local conventions already differ.
 

{rpr_cli-0.2.0/src/rpr/scaffolds → rpr_cli-0.3.1/Sample-dot-github}/instructions/rust-engine.instructions.md

@@ -25,7 +25,8 @@ Use Rust for performance-sensitive code that needs a Python-facing API. This pac
 
 - `engine:build` should run `uv run maturin develop` from the engine package directory.
 - `engine:lint` should run `cargo clippy --all-targets --all-features -- -D warnings`.
-- `engine:format` should run `cargo fmt --check`.
+- `format` should run `cargo fmt`.
+- `format:check` should run `cargo fmt --check`.
 
 ## Binding Conventions
 

{rpr_cli-0.2.0/src/rpr/scaffolds → rpr_cli-0.3.1/Sample-dot-github}/instructions/tooling-setup.instructions.md

@@ -1,6 +1,6 @@
 ---
-applyTo: "pyproject.toml,nx.json,.pre-commit-config.yaml,package.json,apps/*/project.json,packages/**/project.json,apps/*/eslint.config.mjs,packages/**/eslint.config.mjs,packages/python/*_engine/Cargo.toml"
-description: "Use when setting up or modifying Ruff, TypeScript linting, ESLint, Prettier, cargo fmt, Clippy, or pre-commit in an RPR workspace"
+applyTo: "pyproject.toml,nx.json,.pre-commit-config.yaml,package.json,.oxlintrc.json,.oxfmtrc.json,.dependency-cruiser.cjs,apps/*/project.json,packages/**/project.json,packages/python/*_engine/Cargo.toml"
+description: "Use when setting up or modifying Ruff, TypeScript linting, Oxlint, Oxfmt, cargo fmt, Clippy, or pre-commit in an RPR workspace"
 ---
 
 # Tooling Setup
@@ -17,37 +17,24 @@ Use this guidance when editing workspace tooling files or bootstrapping linting,
 
 - Use Ruff for Python linting and formatting.
 - Keep Ruff configuration in the root `pyproject.toml`.
-- Prefer `uv run ruff check` for linting and `uv run ruff format` for formatting.
+- Prefer `uv run ruff check` for linting and `uvx ruff format .` / `uvx ruff format --check .` for Python project format targets.
 - If the workspace already has a Ruff config, extend it rather than replacing it with a different rule set.
 - If bootstrapping from the current RPR defaults, preserve the existing generated baseline unless the task explicitly asks for different rules.
 
 ## TypeScript and React Baseline
 
-- In the current RPR generator, the default `lint` target for Node and React projects is `npx eslint .`.
+- In the current RPR generator, the default `lint` target for Node and React projects is `npx oxlint .`.
 - Keep `typecheck` as a separate target that runs `npx tsc --noEmit`.
-- Use ESLint flat config and the Nx plugin entry `@nx/eslint/plugin` in `nx.json`.
-- Treat Prettier as the default formatter for Node-side code and keep it complementary to ESLint.
-
-Valid `nx.json` plugin example:
-
-```json
-{
-  "plugins": [
-    {
-      "plugin": "@nx/eslint/plugin",
-      "options": {
-        "targetName": "lint"
-      }
-    }
-  ]
-}
-```
+- Use root `.oxlintrc.json` and `.oxfmtrc.json` files; Oxlint and Oxfmt discover them when targets run from a nested project directory.
+- Node project `format` and `format:check` targets use `npx oxfmt --write .` and `npx oxfmt --check .`; root `npm run format` and `npm run format:check` run the matching Nx targets across the workspace.
+- Generated frontend projects install `@typescript/native@npm:typescript@^7.0.2` for `npx tsc` and `typescript@npm:@typescript/typescript6@^6.0.2` for tools that require the TypeScript 6 API. Do not restore `baseUrl`, because TypeScript 7 rejects it; keep Vite client types explicit in the generated web app configuration.
+- Keep `.dependency-cruiser.cjs` and `npm run boundaries` aligned with the generated module-boundary rules. Do not reintroduce ESLint solely for boundary checking.
 
 ## Rust Baseline
 
 - Use `cargo fmt --check` for formatting validation.
 - Use `cargo clippy --all-targets --all-features -- -D warnings` for linting.
-- In RPR-generated engine packages, prefer the existing Nx targets `engine:format` and `engine:lint`.
+- In RPR-generated engine packages, `format` runs `cargo fmt`, `format:check` runs `cargo fmt --check`, and `engine:lint` runs Clippy.
 
 ## Pre-commit Rules
 
@@ -55,7 +42,7 @@ Valid `nx.json` plugin example:
 - Define one hook per command. Do not reuse a single hook entry for two commands.
 - Hook ids, documented manual run commands, and actual entries must match exactly.
 - Prefer commands the workspace already uses in `project.json`, `package.json`, or root scripts.
-- When bootstrapping a fresh RPR workspace, scaffold `eslint` and `prettier` hooks with the matching config files.
+- When bootstrapping a fresh RPR workspace, scaffold `oxlint` and `oxfmt` hooks with the matching config files.
 
 Valid local hook example aligned with the current RPR defaults:
 
@@ -75,15 +62,21 @@ repos:
         language: system
         pass_filenames: false
 
-      - id: prettier
-        name: Prettier
-        entry: npx prettier --write .
+      - id: oxfmt
+        name: Oxfmt
+        entry: npx oxfmt --write .
+        language: system
+        pass_filenames: false
+
+      - id: oxlint
+        name: Oxlint (NX)
+        entry: npx nx run-many --target=lint --all --exclude=engine -- --fix
         language: system
         pass_filenames: false
 
-      - id: eslint
-        name: ESLint
-        entry: npx eslint . --ext .js,.jsx,.ts,.tsx --fix
+      - id: module-boundaries
+        name: Module boundaries
+        entry: npx depcruise apps packages/node
         language: system
         pass_filenames: false
 ```
@@ -91,7 +84,8 @@ repos:
 ## Consistency Checks
 
 - Use `package.json`, not `packages.json`.
-- If linting uses ESLint, keep a separate `typecheck` target for `npx tsc --noEmit`.
-- If you introduce a hook named `eslint` or `prettier`, define that hook explicitly.
-- If you document ESLint, ensure the package install, config format, Nx integration, and manual commands all match.
+- Keep a separate `typecheck` target for `npx tsc --noEmit`; Oxlint does not replace TypeScript compilation.
+- If you introduce a hook named `oxlint` or `oxfmt`, define that hook explicitly.
+- Keep the `module-boundaries` hook aligned with the root `boundaries` script and `.dependency-cruiser.cjs`.
+- If you document Oxc, ensure the package install, config format, Nx integration, and manual commands all match.
 - If a long-form guide conflicts with the generated project defaults, update the guide or the generator so they agree.

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/Sample-dot-github/instructions/tooling.instructions.md

@@ -11,32 +11,33 @@ Use the workspace's existing linting, formatting, and pre-commit setup when it a
 
 - Use Ruff for Python linting and formatting.
 - Keep Ruff configuration in the root `pyproject.toml` under `[tool.ruff]`.
-- Prefer workspace commands such as `uv run ruff check` and `uv run ruff format`.
+- Use `uvx ruff format .` and `uvx ruff format --check .` through each Python project's Nx `format` and `format:check` targets.
 - If the project already pins Ruff in dependencies, keep it there. Do not rely on undocumented cache behavior as the only installation path.
 
 ## TypeScript and React
 
-- In RPR-generated workspaces, use ESLint flat config for JavaScript and TypeScript linting, Prettier for formatting, and `npx tsc --noEmit` as a separate typecheck target.
-- Keep the root `nx.json` ESLint plugin entry and project-local `eslint.config.mjs` files aligned.
-- Extend existing flat-config files instead of introducing a different ESLint config format.
-- Keep `lint`, `format`, and `typecheck` responsibilities separate. Do not use TypeScript typechecking as a substitute for ESLint.
+- In RPR-generated workspaces, use Oxlint for JavaScript and TypeScript linting, Oxfmt for Node project formatting, and `npx tsc --noEmit` as a separate typecheck target.
+- Keep root `.oxlintrc.json` and `.oxfmtrc.json` configuration aligned with generated Nx targets and pre-commit hooks.
+- Use `npm run format` and `npm run format:check` to orchestrate every project's matching Nx target; do not invoke Oxfmt over the repository root.
+- Keep `lint`, `format`, and `typecheck` responsibilities separate. Do not use TypeScript typechecking as a substitute for Oxlint.
+- Keep `.dependency-cruiser.cjs` and `npm run boundaries` aligned with the generated import-boundary rules.
 
 ## Rust
 
 - Use `cargo fmt --check` for formatting validation.
 - Use `cargo clippy --all-targets --all-features -- -D warnings` for linting.
-- Prefer existing Nx targets such as `engine:format` and `engine:lint` when they exist.
+- Use the engine's `format` and `format:check` targets for `cargo fmt` and `cargo fmt --check`; retain `engine:lint` for Clippy.
 
 ## Pre-commit
 
 - Pre-commit hooks must call commands that already exist in the workspace.
 - Keep hook ids, entries, and manual run examples aligned. Do not document a hook name that is not defined.
 - Prefer running workspace-level commands through `uv run`, `npx`, `npx nx`, or existing package-manager scripts rather than ad hoc shell fragments.
-- When the default Node tooling is scaffolded, keep `eslint` and `prettier` hooks aligned with the generated config files.
+- When the default Node tooling is scaffolded, keep `oxlint` and `oxfmt` hooks aligned with the generated config files.
 - Ensure YAML examples are syntactically valid before adding them to shared docs or instructions.
 
 ## Change Discipline
 
-- Reuse existing root config files such as `pyproject.toml`, `nx.json`, `eslint.config.mjs`, and `.pre-commit-config.yaml` instead of creating duplicates.
+- Reuse existing root config files such as `pyproject.toml`, `nx.json`, `.oxlintrc.json`, `.oxfmtrc.json`, and `.pre-commit-config.yaml` instead of creating duplicates.
 - When a task is specifically to bootstrap tooling from scratch, keep the configuration consistent across docs, generated targets, and hook examples.
 - Use `tooling-setup.instructions.md` for file-level guidance when editing root tooling config files.

rpr_cli-0.3.1/src/rpr/__init__.py

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

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/src/rpr/checks/packages.py

@@ -67,7 +67,7 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
             _check_project_targets(
                 area="Domain targets",
                 project_json=domain_dir / "project.json",
-                required_targets={"build", "test", "lint"},
+                required_targets={"build", "test", "lint", "format", "format:check"},
                 suggestion=f"rpr generate domain {name}",
             )
         )
@@ -130,7 +130,14 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
             _check_project_targets(
                 area="API targets",
                 project_json=api_dir / "project.json",
-                required_targets={"serve", "build", "test", "lint"},
+                required_targets={
+                    "serve",
+                    "build",
+                    "test",
+                    "lint",
+                    "format",
+                    "format:check",
+                },
                 suggestion=f"rpr generate api {name}",
             )
         )
@@ -173,7 +180,14 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
             _check_project_targets(
                 area="UI targets",
                 project_json=ui_dir / "project.json",
-                required_targets={"build", "lint", "test", "typecheck"},
+                required_targets={
+                    "build",
+                    "lint",
+                    "format",
+                    "format:check",
+                    "test",
+                    "typecheck",
+                },
                 suggestion=f"rpr generate ui {name}",
             )
         )
@@ -202,7 +216,15 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
             _check_project_targets(
                 area="Web targets",
                 project_json=web_dir / "project.json",
-                required_targets={"serve", "build", "lint", "test", "typecheck"},
+                required_targets={
+                    "serve",
+                    "build",
+                    "lint",
+                    "format",
+                    "format:check",
+                    "test",
+                    "typecheck",
+                },
                 suggestion=f"rpr generate ui {name} --no-library",
             )
         )
@@ -235,6 +257,8 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
                     "serve",
                     "build",
                     "lint",
+                    "format",
+                    "format:check",
                     "test",
                     "typecheck",
                     "storybook",
@@ -264,6 +288,19 @@ def check_packages(project_dir: Path, variables: dict[str, str]) -> list[CheckRe
         )
     )
     if engine_dir is not None:
+        results.append(
+            _check_project_targets(
+                area="Engine targets",
+                project_json=engine_dir / "project.json",
+                required_targets={
+                    "engine:build",
+                    "engine:lint",
+                    "format",
+                    "format:check",
+                },
+                suggestion=f"rpr generate engine {name}",
+            )
+        )
         results.append(
             _check_engine_install_metadata(
                 engine_dir=engine_dir,

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/src/rpr/checks/workspace.py

@@ -20,7 +20,7 @@ def check_workspace(project_dir: Path) -> list[CheckResult]:
             nx_data = json.loads(nx_json.read_text())
             nx_ok = True
             nx_cloud_disabled = nx_data.get("neverConnectToCloud") is True
-        except (OSError, json.JSONDecodeError):
+        except OSError, json.JSONDecodeError:
             nx_ok = False
 
     results.append(
@@ -53,7 +53,7 @@ def check_workspace(project_dir: Path) -> list[CheckResult]:
             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):
+        except OSError, tomllib.TOMLDecodeError:
             uv_ok = False
 
     results.append(
@@ -76,8 +76,12 @@ def check_workspace(project_dir: Path) -> list[CheckResult]:
         uv_require_version = "required-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 []
+    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",
@@ -113,7 +117,7 @@ def check_workspace(project_dir: Path) -> list[CheckResult]:
                 "apps/*",
                 "packages/node/*",
             }.issubset(set(workspaces))
-        except (OSError, json.JSONDecodeError):
+        except OSError, json.JSONDecodeError:
             node_workspace_ok = False
 
     results.append(
@@ -139,7 +143,9 @@ def check_workspace(project_dir: Path) -> list[CheckResult]:
                 "nbstripout",
                 "uv run ruff format",
                 "uv run ruff check --fix",
-                "npx nx run-many --target=lint --all --fix --exclude=engine",
+                "npx oxfmt --write .",
+                "npx nx run-many --target=lint --all --exclude=engine -- --fix",
+                "npx depcruise apps packages/node",
             )
         )
 

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/src/rpr/commands/generate/api.py

@@ -137,6 +137,20 @@ def _write_api_project_json(ctx: RunContext, api_root: Path, app_name: str) -> N
                     "cwd": f"apps/{app_name}",
                 },
             },
+            "format": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "uvx ruff format .",
+                    "cwd": f"apps/{app_name}",
+                },
+            },
+            "format:check": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "uvx ruff format --check .",
+                    "cwd": f"apps/{app_name}",
+                },
+            },
         },
     }
     ctx.write_file(api_root / "project.json", json.dumps(project, indent=2) + "\n")
@@ -152,6 +166,8 @@ from starlette.responses import JSONResponse
 
 from {domain_underscore}.config.container import Container
 
+from .routes.health import router as health_router
+
 _container = Container()
 
 
@@ -167,11 +183,17 @@ async def lifespan(app: FastAPI):
 
 
 async def generic_exception_handler(request: Request, exc: Exception) -> JSONResponse:
-    return JSONResponse(status_code=500, content={{"message": "Internal server error"}})
+    return JSONResponse(
+        status_code=500,
+        content={{"message": "Internal server error"}},
+    )
 
 
 async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
-    return JSONResponse(status_code=422, content={{"message": "Validation error", "details": exc.errors()}})
+    return JSONResponse(
+        status_code=422,
+        content={{"message": "Validation error", "details": exc.errors()}},
+    )
 
 
 def create_app() -> FastAPI:
@@ -184,8 +206,6 @@ def create_app() -> FastAPI:
 
     app.add_exception_handler(Exception, generic_exception_handler)
     app.add_exception_handler(RequestValidationError, validation_exception_handler)
-    from .routes.health import router as health_router
-
     app.include_router(health_router, prefix="/api/health", tags=["Health"])
 
     return app

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/src/rpr/commands/generate/domain.py

@@ -39,6 +39,13 @@ def domain(
     dry_run: Annotated[
         bool, typer.Option("--dry-run", help="Preview changes without writing.")
     ] = False,
+    utilities: Annotated[
+        bool,
+        typer.Option(
+            "--utilities/--no-utilities",
+            help="Offer common utility templates after scaffolding.",
+        ),
+    ] = True,
 ) -> None:
     """Scaffold a DDD Python domain package."""
     if not name:
@@ -109,7 +116,7 @@ def domain(
     console.print(f"\n[bold green]Done![/] Domain package created at {domain_root}")
 
     # --- post-scaffold utility prompt --------------------------------------
-    if not dry_run:
+    if utilities:
         _offer_utility_templates(ctx, name)
 
 
@@ -192,6 +199,20 @@ def _write_project_json(
                     "command": f"uv run ruff check {root}/src",
                 },
             },
+            "format": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "uvx ruff format .",
+                    "cwd": root,
+                },
+            },
+            "format:check": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "uvx ruff format --check .",
+                    "cwd": root,
+                },
+            },
         },
     }
     if include_migrations:
@@ -386,5 +407,9 @@ def _offer_utility_templates(ctx: RunContext, name: str) -> None:
         console.print(f"  [dim]rpr add template python {t} --name {name}[/]")
 
     if typer.confirm("\nWould you like to add these utilities now?", default=False):
-        for t in _UTILITY_TEMPLATES:
-            ctx.run_command(["rpr", "add", "template", "python", t, "--name", name])
+        _add_utility_templates(ctx, name)
+
+
+def _add_utility_templates(ctx: RunContext, name: str) -> None:
+    for template in _UTILITY_TEMPLATES:
+        ctx.run_command(["rpr", "add", "template", "python", template, "--name", name])

{rpr_cli-0.2.0 → rpr_cli-0.3.1}/src/rpr/commands/generate/engine.py

@@ -137,7 +137,14 @@ def _write_engine_project_json(
                     "cwd": f"packages/python/{engine_name}",
                 },
             },
-            "engine:format": {
+            "format": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "cargo fmt",
+                    "cwd": f"packages/python/{engine_name}",
+                },
+            },
+            "format:check": {
                 "executor": "nx:run-commands",
                 "options": {
                     "command": "cargo fmt --check",