rpr-cli 0.1.1__py3-none-any.whl

rpr/ui/theme.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.theme import Theme
+
+
+@dataclass
+class UIStyles:
+    success: str = "green"
+    warning: str = "yellow"
+    error: str = "red"
+    info: str = "blue"
+    muted: str = "dim"
+    heading: str = "bold"
+    command: str = "bold blue"
+    dry_run: str = "bold yellow"
+    path: str = "cyan"
+    line_number: str = "dim"
+    border: str = "dim"
+
+
+def create_rich_theme(styles: UIStyles) -> Theme:
+    return Theme(
+        {
+            "success": styles.success,
+            "warning": styles.warning,
+            "error": styles.error,
+            "info": styles.info,
+            "muted": styles.muted,
+            "heading": styles.heading,
+            "command": styles.command,
+            "dry_run": styles.dry_run,
+            "path": styles.path,
+            "line_number": styles.line_number,
+            "border": styles.border,
+        }
+    )
+
+
+THEMES = {
+    "standard": UIStyles(),
+    "monochrome": UIStyles(
+        success="bold white",
+        warning="white",
+        error="bold white",
+        info="white",
+        muted="dim",
+        heading="bold",
+        command="bold",
+        dry_run="bold",
+        path="white",
+    ),
+    "vibrant": UIStyles(
+        success="bold bright_green",
+        warning="bold bright_yellow",
+        error="bold bright_red",
+        info="bold bright_blue",
+        command="bold bright_magenta",
+        dry_run="bold bright_yellow",
+        path="bright_cyan",
+    ),
+    "ocean": UIStyles(
+        success="green",
+        warning="yellow",
+        error="red",
+        info="blue",
+        command="cyan",
+        dry_run="bright_blue",
+        path="bright_cyan",
+        heading="bold blue",
+    ),
+    "dracula": UIStyles(
+        success="#50fa7b",
+        warning="#f1fa8c",
+        error="#ff5555",
+        info="#8be9fd",
+        command="#bd93f9",
+        dry_run="#f1fa8c",
+        path="#8be9fd",
+        heading="bold #ff79c6",
+        muted="#6272a4",
+        border="#6272a4",
+    ),
+}
+
+
+@dataclass(slots=True, frozen=True)
+class SettingDefinition:
+    key: str
+    description: str
+    kind: str
+    default: str | bool
+    choices: tuple[str, ...] = ()
+
+
+SETTING_DEFINITIONS = {
+    "theme": SettingDefinition(
+        key="theme",
+        description="Terminal theme for Rich output.",
+        kind="choice",
+        default="standard",
+        choices=tuple(THEMES),
+    ),
+    "approval_mode": SettingDefinition(
+        key="approval_mode",
+        description="Default approval mode for chat tool calls.",
+        kind="choice",
+        default="ask",
+        choices=("ask", "auto-readonly", "auto-all"),
+    ),
+    "startup_help": SettingDefinition(
+        key="startup_help",
+        description="Show slash-command guidance when chat starts.",
+        kind="bool",
+        default=True,
+    ),
+}
+
+
+def _coerce_bool(value: object) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in {"1", "true", "t", "yes", "y", "on"}:
+            return True
+        if normalized in {"0", "false", "f", "no", "n", "off"}:
+            return False
+    raise ValueError("Expected a boolean value: true/false, yes/no, or on/off.")
+
+
+class SettingsManager:
+    _instance: SettingsManager | None = None
+    _current_theme_name: str = "standard"
+    _approval_mode_name: str = "ask"
+    _startup_help: bool = True
+    _config_path: Path = Path.home() / ".rpr" / "settings.json"
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SettingsManager, cls).__new__(cls)
+            cls._instance._load_settings()
+        return cls._instance
+
+    @staticmethod
+    def definitions() -> dict[str, SettingDefinition]:
+        return SETTING_DEFINITIONS
+
+    def _default_data(self) -> dict[str, str | bool]:
+        return {
+            key: definition.default for key, definition in SETTING_DEFINITIONS.items()
+        }
+
+    def _load_settings(self):
+        data = self._default_data()
+        if self._config_path.exists():
+            try:
+                loaded = json.loads(self._config_path.read_text())
+            except json.JSONDecodeError, OSError:
+                loaded = {}
+            if isinstance(loaded, dict):
+                data.update(loaded)
+
+        self._current_theme_name = self._coerce_value(
+            "theme", data.get("theme", "standard")
+        )
+        self._approval_mode_name = self._coerce_value(
+            "approval_mode",
+            data.get("approval_mode", "ask"),
+        )
+        self._startup_help = self._coerce_value(
+            "startup_help", data.get("startup_help", True)
+        )
+
+    def _save_settings(self):
+        self._config_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self._config_path.write_text(
+                json.dumps(
+                    {
+                        "theme": self._current_theme_name,
+                        "approval_mode": self._approval_mode_name,
+                        "startup_help": self._startup_help,
+                    },
+                    indent=2,
+                )
+            )
+        except OSError:
+            pass
+
+    def _coerce_value(self, key: str, value: object) -> str | bool:
+        definition = SETTING_DEFINITIONS[key]
+        if definition.kind == "bool":
+            return _coerce_bool(value)
+
+        if not isinstance(value, str):
+            raise ValueError(f"Expected a string value for {key}.")
+
+        if definition.choices and value not in definition.choices:
+            allowed = ", ".join(definition.choices)
+            if key == "theme":
+                raise ValueError(f"Unknown theme: {value}")
+            raise ValueError(f"Unknown value for {key}: {value}. Valid: {allowed}")
+        return value
+
+    def get_value(self, key: str) -> str | bool:
+        if key not in SETTING_DEFINITIONS:
+            raise KeyError(key)
+        if key == "theme":
+            return self._current_theme_name
+        if key == "approval_mode":
+            return self._approval_mode_name
+        if key == "startup_help":
+            return self._startup_help
+        raise KeyError(key)
+
+    def set_value(self, key: str, value: object) -> str | bool:
+        if key not in SETTING_DEFINITIONS:
+            raise KeyError(key)
+
+        coerced = self._coerce_value(key, value)
+        if key == "theme":
+            self._current_theme_name = coerced
+        elif key == "approval_mode":
+            self._approval_mode_name = coerced
+        elif key == "startup_help":
+            self._startup_help = coerced
+        else:
+            raise KeyError(key)
+
+        self._save_settings()
+        return coerced
+
+    def describe_settings(self) -> list[tuple[SettingDefinition, str]]:
+        rows: list[tuple[SettingDefinition, str]] = []
+        for key, definition in SETTING_DEFINITIONS.items():
+            value = self.get_value(key)
+            if isinstance(value, bool):
+                display = "true" if value else "false"
+            else:
+                display = value
+            rows.append((definition, display))
+        return rows
+
+    @property
+    def current_theme_name(self) -> str:
+        return self._current_theme_name
+
+    @current_theme_name.setter
+    def current_theme_name(self, name: str):
+        self.set_value("theme", name)
+
+    @property
+    def approval_mode_name(self) -> str:
+        return self._approval_mode_name
+
+    @approval_mode_name.setter
+    def approval_mode_name(self, name: str) -> None:
+        self.set_value("approval_mode", name)
+
+    @property
+    def approval_mode(self):
+        from rpr.agent.approval import ApprovalMode
+
+        return ApprovalMode(self._approval_mode_name)
+
+    @property
+    def startup_help(self) -> bool:
+        return self._startup_help
+
+    @startup_help.setter
+    def startup_help(self, enabled: bool) -> None:
+        self.set_value("startup_help", enabled)
+
+    def get_theme(self) -> Theme:
+        return create_rich_theme(THEMES[self._current_theme_name])
+
+    def get_styles(self) -> UIStyles:
+        return THEMES[self._current_theme_name]
+
+
+settings_manager = SettingsManager()
+theme_manager = settings_manager

rpr/workspace.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from rich.console import Console
+
+from rpr.context import RunContext
+
+console = Console()
+DEFAULT_NPM_WORKSPACES = ["apps/*", "packages/node/*"]
+
+
+def add_workspace_member(ctx: RunContext, member: str) -> None:
+    """Add a UV workspace member to the root pyproject.toml."""
+    pyproject_path = ctx.project_dir / "pyproject.toml"
+    if ctx.dry_run:
+        console.print(
+            f"[bold yellow][DRY RUN][/] Would add '{member}' to workspace members in {pyproject_path}",
+            soft_wrap=True,
+        )
+        return
+
+    import tomllib
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    members = data.get("tool", {}).get("uv", {}).get("workspace", {}).get("members", [])
+    if member in members:
+        return
+
+    members.append(member)
+    members_str = ", ".join(f'"{m}"' for m in members)
+    new_members_line = f"members = [{members_str}]"
+
+    content = pyproject_path.read_text()
+    content = re.sub(
+        r"members\s*=\s*\[.*?\]", new_members_line, content, flags=re.DOTALL
+    )
+    pyproject_path.write_text(content)
+    console.print(f"[bold green]Updated:[/] Added '{member}' to workspace members")
+
+
+def derive_variables(project_name: str) -> dict[str, str]:
+    """Derive the four canonical token variants from the raw project name."""
+    name_underscore = project_name.replace("-", "_")
+    pascal = "".join(w.capitalize() for w in re.split(r"[-_]+", project_name) if w)
+    return {
+        "name": project_name,
+        "name-of-app": project_name,
+        "name_underscore": name_underscore,
+        "NamePascal": pascal,
+    }
+
+
+def write_package_json(
+    ctx: RunContext,
+    path: Path,
+    *,
+    defaults: dict[str, object] | None = None,
+    dependencies: dict[str, str] | None = None,
+    dev_dependencies: dict[str, str] | None = None,
+) -> None:
+    """Create or update a package.json while preserving existing package pins."""
+    package: dict[str, object]
+    existed = path.exists()
+
+    if existed:
+        try:
+            package = json.loads(path.read_text())
+        except json.JSONDecodeError:
+            package = {}
+    else:
+        package = {}
+
+    for key, value in (defaults or {}).items():
+        package.setdefault(key, value)
+
+    for field_name, additions in (
+        ("dependencies", dependencies or {}),
+        ("devDependencies", dev_dependencies or {}),
+    ):
+        field = package.setdefault(field_name, {})
+        if not isinstance(field, dict):
+            field = {}
+            package[field_name] = field
+        for dep_name, version in additions.items():
+            field.setdefault(dep_name, version)
+
+    content = json.dumps(package, indent=2) + "\n"
+    if existed:
+        ctx.update_file(path, content)
+    else:
+        ctx.write_file(path, content)
+
+
+def ensure_npm_workspaces(ctx: RunContext, *, package_name: str | None = None) -> None:
+    """Ensure the root package.json declares the standard npm workspace globs."""
+    package_path = ctx.project_dir / "package.json"
+    package: dict[str, object]
+    existed = package_path.exists()
+
+    if existed:
+        try:
+            package = json.loads(package_path.read_text())
+        except json.JSONDecodeError:
+            package = {}
+    else:
+        package = {}
+
+    if package_name:
+        package.setdefault("name", package_name)
+    package["private"] = True
+
+    workspaces = package.get("workspaces", [])
+    if not isinstance(workspaces, list):
+        workspaces = []
+
+    for workspace in DEFAULT_NPM_WORKSPACES:
+        if workspace not in workspaces:
+            workspaces.append(workspace)
+
+    package["workspaces"] = workspaces
+
+    content = json.dumps(package, indent=2) + "\n"
+    if existed:
+        ctx.update_file(package_path, content)
+    else:
+        ctx.write_file(package_path, content)

rpr_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: rpr-cli
+Version: 0.1.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: 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.
+
+## Installation
+
+Published package name: `rpr-cli`
+
+Once published to PyPI, install by name with either:
+
+```bash
+uv add rpr-cli
+uv tool install rpr-cli
+```
+
+Both install the `rpr` command.
+
+For development, editable install is fine:
+
+```bash
+uv tool install -e .
+```
+
+For an actual distributable install you can use in other projects, build the wheel first and install the built artifact:
+
+```bash
+uv build
+uv tool install dist/rpr_cli-*.whl
+```
+
+From another local project you can also install the built artifact directly:
+
+```bash
+uv add ../project-getting-started/dist/rpr_cli-*.whl
+```
+
+## Usage
+
+### 🚀 Scaffolding & Generation
+
+Scaffold a complete monorepo or add new apps and libraries.
+
+```bash
+rpr init my-app              # Scaffold a new monorepo (NX + UV)
+rpr generate domain my-app   # Add a domain package (shared logic & types)
+rpr generate api my-app      # Add a FastAPI application
+rpr generate ui my-app       # Add a React UI library + application
+rpr generate engine my-app   # Add a Rust/PyO3 computation engine
+rpr generate storybook       # Add Storybook for UI component development
+```
+
+### 🧠 AI Instructions & Code Templates
+
+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 mapper_util # Add a common code template to your project
+rpr add template --list      # List all available code templates
+```
+
+### 💬 Interactive Shell
+
+`rpr chat` is the primary interactive shell for the product. It runs a Rich-based session with slash commands for both chat controls and existing CLI workflows.
+
+```bash
+rpr chat                                 # Start the interactive shell
+rpr chat --approval-mode auto-readonly   # Override the session approval mode
+```
+
+Inside the shell:
+
+```text
+/help        List supported slash commands
+/settings    Inspect and update persisted settings in-shell
+/init        Run workspace bootstrap from chat
+/generate    Run scaffolding commands from chat
+/sync        Sync AI instructions from chat
+/add         Add a registered template from chat
+/check       Run workspace health checks from chat
+/map         Generate a code map from chat
+/exit        End the session
+```
+
+There is no separate `--tui` mode. The unified shell is the default chat experience.
+
+### 🛠️ Maintenance & Insights
+
+Keep your project healthy and explore its structure.
+
+```bash
+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
+rpr settings set theme ocean # Update the terminal theme
+rpr settings set approval_mode auto-all
+rpr settings set startup_help false
+```
+
+Persisted settings currently include:
+
+- `theme`: Rich console theme
+- `approval_mode`: default chat approval mode (`ask`, `auto-readonly`, `auto-all`)
+- `startup_help`: whether chat shows slash-command guidance on startup
+
+### ⚙️ Common Flags
+
+Most commands support these global flags:
+
+- `--dry-run`: Preview changes without writing any files.
+- `--help`: Show detailed help for any command or subcommand.
+
+Example:
+
+```bash
+rpr generate api my-app --dry-run
+```
+
+The `check` command also supports:
+
+- `--json`: Output machine-readable JSON for CI/CD integration.
+
+The `chat` command also supports:
+
+- `--provider`: Override the AI provider. The mock provider is the only supported provider today.
+- `--model`: Override the active model name.
+- `--approval-mode`: Override the session approval mode without changing persisted settings.
+
+### Project Development
+
+#### Setup
+
+```bash
+# Install Python dependencies
+uv sync
+
+# Build the Rust extension (rpr_parser) — required for rpr map acceleration
+cd rpr-parser && uv run maturin develop && cd ..
+```
+
+> **Note:** `uv tool install dist/rpr-*.whl` uses the root hatchling build backend and does **not** build the
+> Rust extension. You must run `maturin develop` separately before using `rpr map` with the Rust
+> backend. Without it, `rpr map` falls back to the pure-Python implementation automatically.
+
+#### Running Tests
+
+```bash
+# Full test suite (Python)
+uv run pytest
+
+# Single test file
+uv run pytest tests/test_map_extractor.py
+
+# Single test
+uv run pytest tests/test_map_extractor.py::test_fallback_returns_correct_shape
+
+# Rust unit tests (rpr_parser crate)
+cd rpr-parser && cargo test && cd ..
+
+# Lint and format
+uv run ruff check .
+uv run ruff format .
+```
+
+The Rust-path tests in `tests/test_map_extractor.py` are automatically skipped if the Rust
+extension hasn't been built yet — run `maturin develop` first to enable them.
+
+### Publishing To PyPI
+
+This repo is set up to publish the package `rpr-cli` to PyPI from GitHub Actions.
+
+One-time setup:
+
+1. Create the PyPI project `rpr-cli`.
+2. Add a repository secret named `PYPI_API_TOKEN` with an API token that can upload that project.
+
+Release flow:
+
+```bash
+# update src/rpr/__init__.py with the new version
+git commit -am "Release 0.1.2"
+git tag v0.1.2
+git push origin main --tags
+```
+
+The workflow in `.github/workflows/publish-pypi.yml` builds the sdist and wheel, checks that the tag matches the package version, and uploads `dist/*` to PyPI.