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

rpr_cli-0.1.30/README.md → rpr_cli-0.2.1/PKG-INFO

@@ -1,3 +1,20 @@
+Metadata-Version: 2.4
+Name: rpr-cli
+Version: 0.2.1
+Summary: RPR CLI -- React Python Rust monorepo scaffolding orchestrator
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: jinja2>=3.1.5
+Requires-Dist: packaging>=26.2
+Requires-Dist: pathspec>=1.0.4
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=14.3.3
+Requires-Dist: tomlkit>=0.15.0
+Requires-Dist: typer>=0.24.1
+Description-Content-Type: text/markdown
+
 # RPR CLI
 
 React Python Rust monorepo scaffolding orchestrator.
@@ -85,6 +102,8 @@ RPR keeps dependencies close to the package that uses them.
 
 Python dependency changes are made with `uv` so they are tracked in `pyproject.toml`. Node dependency changes are made through npm workspace package metadata and root `npm install`.
 
+Update project-owned package manifests from upstream registries with `rpr update node` or `rpr update python`. Node updates target `package.json`; Python updates target `pyproject.toml` by default and fall back to `requirements.txt` when no `pyproject.toml` exists. Use `--file` to update a nested manifest, `--dry-run` to preview without changing files or running installers, and `--include-major` to opt into major-version updates.
+
 The scaffold version manifest that powers generated dependency specs and the synced AI tech-stack overview lives in `src/rpr/dependency_manifest_data.py`. Refresh it from upstream registries with `rpr refresh manifest` when you want the repo-owned defaults to move forward.
 
 ### 🧠 AI Instructions & Code Templates
@@ -133,6 +152,8 @@ Keep your project healthy and explore its structure.
 
 ```bash
 rpr refresh manifest         # Refresh the scaffold dependency manifest from npm, PyPI, and crates.io
+rpr update node              # Update package.json dependencies and run npm install
+rpr update python            # Update pyproject.toml or requirements.txt and sync Python dependencies
 rpr check                    # Inspect project health and report setup status
 rpr map                      # Generate a structured code map of your project
 rpr settings                 # Inspect persisted shell settings
@@ -149,6 +170,8 @@ Persisted settings currently include:
 
 `rpr refresh manifest` is a repo-maintenance command. It rewrites `src/rpr/dependency_manifest_data.py`, which feeds scaffold dependency versions in `rpr generate ...` and the versioned overview text produced by `rpr sync rules`. Use `--dry-run` to preview the manifest rewrite without writing the file.
 
+`rpr update node` and `rpr update python` are project-maintenance commands. They update the selected package manifest, print applied and held-back dependency changes, and run the matching installer only when live changes are written. Without `--include-major`, RPR chooses the latest stable version inside the current major version and reports higher-major candidates as held back. Python updates cover `[project].dependencies`, `[dependency-groups].*`, and `requirements.txt`; build backend packages in `[build-system].requires` are left unchanged unless a future explicit build-system update option is added.
+
 ### ⚙️ Common Flags
 
 Most commands support these global flags:

rpr_cli-0.1.30/PKG-INFO → rpr_cli-0.2.1/README.md

@@ -1,18 +1,3 @@
-Metadata-Version: 2.4
-Name: rpr-cli
-Version: 0.1.30
-Summary: RPR CLI -- React Python Rust monorepo scaffolding orchestrator
-License-Expression: MIT
-License-File: LICENSE
-Requires-Python: >=3.14
-Requires-Dist: jinja2>=3.1.5
-Requires-Dist: pathspec>=1.0.4
-Requires-Dist: prompt-toolkit>=3.0.52
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: rich>=14.3.3
-Requires-Dist: typer>=0.24.1
-Description-Content-Type: text/markdown
-
 # RPR CLI
 
 React Python Rust monorepo scaffolding orchestrator.
@@ -100,6 +85,8 @@ RPR keeps dependencies close to the package that uses them.
 
 Python dependency changes are made with `uv` so they are tracked in `pyproject.toml`. Node dependency changes are made through npm workspace package metadata and root `npm install`.
 
+Update project-owned package manifests from upstream registries with `rpr update node` or `rpr update python`. Node updates target `package.json`; Python updates target `pyproject.toml` by default and fall back to `requirements.txt` when no `pyproject.toml` exists. Use `--file` to update a nested manifest, `--dry-run` to preview without changing files or running installers, and `--include-major` to opt into major-version updates.
+
 The scaffold version manifest that powers generated dependency specs and the synced AI tech-stack overview lives in `src/rpr/dependency_manifest_data.py`. Refresh it from upstream registries with `rpr refresh manifest` when you want the repo-owned defaults to move forward.
 
 ### 🧠 AI Instructions & Code Templates
@@ -148,6 +135,8 @@ Keep your project healthy and explore its structure.
 
 ```bash
 rpr refresh manifest         # Refresh the scaffold dependency manifest from npm, PyPI, and crates.io
+rpr update node              # Update package.json dependencies and run npm install
+rpr update python            # Update pyproject.toml or requirements.txt and sync Python dependencies
 rpr check                    # Inspect project health and report setup status
 rpr map                      # Generate a structured code map of your project
 rpr settings                 # Inspect persisted shell settings
@@ -164,6 +153,8 @@ Persisted settings currently include:
 
 `rpr refresh manifest` is a repo-maintenance command. It rewrites `src/rpr/dependency_manifest_data.py`, which feeds scaffold dependency versions in `rpr generate ...` and the versioned overview text produced by `rpr sync rules`. Use `--dry-run` to preview the manifest rewrite without writing the file.
 
+`rpr update node` and `rpr update python` are project-maintenance commands. They update the selected package manifest, print applied and held-back dependency changes, and run the matching installer only when live changes are written. Without `--include-major`, RPR chooses the latest stable version inside the current major version and reports higher-major candidates as held back. Python updates cover `[project].dependencies`, `[dependency-groups].*`, and `requirements.txt`; build backend packages in `[build-system].requires` are left unchanged unless a future explicit build-system update option is added.
+
 ### ⚙️ Common Flags
 
 Most commands support these global flags:

{rpr_cli-0.1.30 → rpr_cli-0.2.1}/pyproject.toml

@@ -12,6 +12,8 @@ dependencies = [
     "rich>=14.3.3",
     "pathspec>=1.0.4",
     "prompt-toolkit>=3.0.52",
+    "tomlkit>=0.15.0",
+    "packaging>=26.2",
 ]
 
 [project.scripts]

rpr_cli-0.2.1/src/rpr/__init__.py

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

{rpr_cli-0.1.30 → rpr_cli-0.2.1}/src/rpr/application/catalog.py

@@ -241,6 +241,67 @@ COMMAND_CATALOG: tuple[CommandDefinition, ...] = (
             ),
         ),
     ),
+    CommandDefinition(
+        name="update",
+        description="Update project package manifests from upstream registries.",
+        action_id="update.dispatch",
+        children=(
+            CommandDefinition(
+                name="node",
+                description="Update a package.json manifest and run npm install.",
+                action_id="update.node",
+                options=(
+                    CommandOption(
+                        "--file",
+                        "Package manifest to update.",
+                        kind="value",
+                        value_name="PATH",
+                    ),
+                    CommandOption(
+                        "--include-major",
+                        "Apply available updates across major versions.",
+                        kind="flag",
+                    ),
+                    CommandOption(
+                        "--timeout",
+                        "Per-request registry timeout in seconds.",
+                        kind="value",
+                        value_name="SECONDS",
+                    ),
+                    CommandOption(
+                        "--dry-run", "Preview changes without writing.", kind="flag"
+                    ),
+                ),
+            ),
+            CommandDefinition(
+                name="python",
+                description="Update a Python manifest and run the matching sync command.",
+                action_id="update.python",
+                options=(
+                    CommandOption(
+                        "--file",
+                        "Package manifest to update.",
+                        kind="value",
+                        value_name="PATH",
+                    ),
+                    CommandOption(
+                        "--include-major",
+                        "Apply available updates across major versions.",
+                        kind="flag",
+                    ),
+                    CommandOption(
+                        "--timeout",
+                        "Per-request registry timeout in seconds.",
+                        kind="value",
+                        value_name="SECONDS",
+                    ),
+                    CommandOption(
+                        "--dry-run", "Preview changes without writing.", kind="flag"
+                    ),
+                ),
+            ),
+        ),
+    ),
     CommandDefinition(
         name="add",
         description="Write a registered template into the current project.",

{rpr_cli-0.1.30 → rpr_cli-0.2.1}/src/rpr/cli.py

@@ -39,6 +39,13 @@ refresh_app = typer.Typer(
 )
 app.add_typer(refresh_app, name="refresh")
 
+update_app = typer.Typer(
+    name="update",
+    help="Update project package manifests from upstream registries.",
+    no_args_is_help=True,
+)
+app.add_typer(update_app, name="update")
+
 add_app = typer.Typer(
     name="add",
     help="Add code templates to the current project.",
@@ -54,6 +61,7 @@ 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 refresh as _refresh_mod  # noqa: E402, F401
+from rpr.commands import update as _update_mod  # noqa: E402, F401
 from rpr.commands import add as _add_mod  # noqa: E402, F401
 
 

rpr_cli-0.2.1/src/rpr/commands/update.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from rpr.cli import update_app
+from rpr.context import RunContext
+from rpr.package_updates import (
+    PackageFileKind,
+    PackageUpdateError,
+    PackageUpdatePlan,
+    plan_package_updates,
+)
+from rpr.ui.renderers import render_table
+
+console = Console()
+
+
+@update_app.command("node")
+def node(
+    file: Annotated[
+        str | None,
+        typer.Option("--file", help="Package manifest to update."),
+    ] = None,
+    include_major: Annotated[
+        bool,
+        typer.Option(
+            "--include-major", help="Apply available updates across major versions."
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview changes without writing.")
+    ] = False,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            help="Per-request timeout in seconds when talking to registries.",
+        ),
+    ] = 10.0,
+) -> None:
+    """Update a package.json manifest and run npm install."""
+    ctx = RunContext(dry_run=dry_run, project_dir=Path.cwd())
+    manifest_path = _resolve_manifest_path(file, default=ctx.project_dir / "package.json")
+    plan = _build_plan(
+        manifest_path,
+        "node",
+        include_major=include_major,
+        dry_run=dry_run,
+        timeout=timeout,
+    )
+    _apply_plan(ctx, plan)
+
+
+@update_app.command("python")
+def python(
+    file: Annotated[
+        str | None,
+        typer.Option("--file", help="Package manifest to update."),
+    ] = None,
+    include_major: Annotated[
+        bool,
+        typer.Option(
+            "--include-major", help="Apply available updates across major versions."
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview changes without writing.")
+    ] = False,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            help="Per-request timeout in seconds when talking to registries.",
+        ),
+    ] = 10.0,
+) -> None:
+    """Update a Python manifest and run the matching sync command."""
+    ctx = RunContext(dry_run=dry_run, project_dir=Path.cwd())
+    manifest_path = _resolve_manifest_path(
+        file,
+        default=_default_python_manifest(ctx.project_dir),
+    )
+    plan = _build_plan(
+        manifest_path,
+        "python",
+        include_major=include_major,
+        dry_run=dry_run,
+        timeout=timeout,
+    )
+    _apply_plan(ctx, plan)
+
+
+def _resolve_manifest_path(file: str | None, *, default: Path) -> Path:
+    if file is None:
+        return default
+    path = Path(file).expanduser()
+    if path.is_absolute():
+        return path
+    return Path.cwd() / path
+
+
+def _default_python_manifest(project_dir: Path) -> Path:
+    pyproject = project_dir / "pyproject.toml"
+    if pyproject.exists():
+        return pyproject
+    return project_dir / "requirements.txt"
+
+
+def _build_plan(
+    manifest_path: Path,
+    target: str,
+    *,
+    include_major: bool,
+    dry_run: bool,
+    timeout: float,
+) -> PackageUpdatePlan:
+    try:
+        plan = plan_package_updates(
+            manifest_path,
+            target,  # type: ignore[arg-type]
+            include_major=include_major,
+            timeout=timeout,
+        )
+    except PackageUpdateError as exc:
+        console.print(f"[bold red]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+
+    _render_plan(plan, dry_run=dry_run)
+    return plan
+
+
+def _render_plan(plan: PackageUpdatePlan, *, dry_run: bool) -> None:
+    if not plan.changes:
+        if plan.supported_section_count == 0:
+            console.print(
+                f"[bold green]Done![/] No supported dependency sections in {plan.path}."
+            )
+        else:
+            console.print(f"[bold green]Done![/] {plan.path} is already up to date.")
+        _render_skipped(plan)
+        if dry_run:
+            console.print(
+                "\n[bold yellow]Dry run complete.[/] No manifest or installer command was changed."
+            )
+        return
+
+    action = "Planned" if dry_run else "Applying"
+    console.print(f"\n[bold]{action} package updates[/] ({len(plan.changes)} updates)\n")
+    render_table(
+        "Package updates",
+        ["Path", "Section", "Package", "Old", "New", "Major"],
+        [
+            [
+                str(change.path),
+                change.section,
+                change.package,
+                change.old_specifier,
+                change.new_specifier,
+                "yes" if change.is_major else "no",
+            ]
+            for change in plan.changes
+        ],
+    )
+    _render_skipped(plan)
+    if dry_run:
+        console.print(
+            "\n[bold yellow]Dry run complete.[/] No manifest or installer command was changed."
+        )
+
+
+def _render_skipped(plan: PackageUpdatePlan) -> None:
+    if not plan.skipped:
+        return
+    rows = []
+    for skipped in plan.skipped:
+        reason = skipped.reason
+        if skipped.latest_version:
+            reason = f"{reason} (latest: {skipped.latest_version})"
+        rows.append(
+            [
+                str(skipped.path),
+                skipped.section,
+                skipped.package,
+                skipped.specifier,
+                reason,
+            ]
+        )
+    render_table(
+        "Skipped package updates",
+        ["Path", "Section", "Package", "Specifier", "Reason"],
+        rows,
+    )
+
+
+def _apply_plan(ctx: RunContext, plan: PackageUpdatePlan) -> None:
+    if not plan.has_changes:
+        return
+    if ctx.dry_run:
+        return
+
+    ctx.update_file(plan.path, plan.updated_content)
+    _run_installer(ctx, plan.file_kind, plan.path)
+    console.print(f"\n[bold green]Done![/] Updated package manifest at {plan.path}")
+
+
+def _run_installer(ctx: RunContext, file_kind: PackageFileKind, manifest_path: Path) -> None:
+    if file_kind == "package-json":
+        ctx.run_command(["npm", "install"], cwd=ctx.project_dir)
+        return
+    if file_kind == "pyproject-toml":
+        ctx.run_uv_command(["uv", "sync", "--all-packages"], cwd=ctx.project_dir)
+        return
+    ctx.run_command(
+        ["python", "-m", "pip", "install", "-r", str(manifest_path)],
+        cwd=ctx.project_dir,
+    )

{rpr_cli-0.1.30 → rpr_cli-0.2.1}/src/rpr/manifest_refresh.py

@@ -8,6 +8,8 @@ from typing import Literal
 from urllib.parse import quote
 from urllib.request import Request, urlopen
 
+from packaging.version import InvalidVersion, Version
+
 RegistryName = Literal["npm", "pypi", "cratesio"]
 RefreshStrategy = Literal[
     "caret", "minimum", "exact", "major-range", "latest", "pinned-major"
@@ -64,6 +66,54 @@ def fetch_latest_version(
         ) from exc
 
 
+def fetch_available_versions(
+    registry: RegistryName, package: str, *, timeout: float = 10.0
+) -> list[str]:
+    if registry == "npm":
+        url = f"https://registry.npmjs.org/{quote(package, safe='')}"
+    elif registry == "pypi":
+        url = f"https://pypi.org/pypi/{quote(package, safe='')}/json"
+    else:
+        raise ManifestRefreshError(
+            f"Available-version lookup is not supported for {registry} packages"
+        )
+
+    request = Request(url, headers={"User-Agent": _USER_AGENT})
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            payload = json.load(response)
+    except Exception as exc:  # pragma: no cover - exercised through command tests
+        raise ManifestRefreshError(
+            f"Failed to fetch {registry} metadata for {package}: {exc}"
+        ) from exc
+
+    try:
+        raw_versions = (
+            payload["versions"].keys() if registry == "npm" else payload["releases"].keys()
+        )
+    except Exception as exc:  # pragma: no cover - exercised through command tests
+        raise ManifestRefreshError(
+            f"Registry response for {package} did not include available versions"
+        ) from exc
+
+    versions: list[tuple[Version, str]] = []
+    for raw_version in raw_versions:
+        try:
+            parsed = Version(str(raw_version))
+        except InvalidVersion:
+            continue
+        if parsed.is_prerelease or parsed.is_devrelease:
+            continue
+        versions.append((parsed, str(raw_version)))
+
+    if not versions:
+        raise ManifestRefreshError(
+            f"Registry response for {package} did not include stable versions"
+        )
+
+    return [raw_version for _, raw_version in sorted(versions, reverse=True)]
+
+
 def refresh_dependency_manifest(
     manifest: Manifest,
     *,