rapidkit-core 0.1.2rc2__tar.gz

rapidkit_core-0.1.2rc2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RapidKit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rapidkit_core-0.1.2rc2/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: rapidkit-core
+Version: 0.1.2rc2
+Summary: Public staging playground where we polish the next wave of RapidKit magic together
+License: MIT
+License-File: LICENSE
+Keywords: scaffolding,boilerplate,fastapi,codegen,devtools
+Author: RapidKit Team
+Author-email: team@rapidkit.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Dist: black (>=25.9.0,<26.0.0)
+Requires-Dist: click (>=8.3,<8.4)
+Requires-Dist: cryptography (>=46.0.2,<47.0.0)
+Requires-Dist: email-validator (>=2.1,<3.0)
+Requires-Dist: fastapi (>=0.119.0,<1.0.0)
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: jsonschema (>=4.25.1,<5.0.0)
+Requires-Dist: packaging (>=25.0,<26.0)
+Requires-Dist: pydantic (>=2.12.2)
+Requires-Dist: pydantic-settings (>=2.11,<3.0)
+Requires-Dist: pygithub (>=2.7.0,<3.0.0)
+Requires-Dist: pynacl (>=1.5.0,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Requires-Dist: starlette (>=0.49.1,<0.50)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: typer (>=0.19,<0.20)
+Requires-Dist: types-requests (>=2.32.4.20250913,<3.0.0.0)
+Requires-Dist: uvicorn[standard] (>=0.37.0)
+Requires-Dist: yamllint (>=1.37.1,<2.0.0)
+Project-URL: Homepage, https://github.com/getrapidkit/community-staging
+Project-URL: Repository, https://github.com/getrapidkit/community-staging
+Description-Content-Type: text/markdown
+
+# RapidKit Community-staging
+
+Public staging playground where we polish the next wave of RapidKit magic together
+
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 🚀 Features
+
+- Clean Architecture FastAPI applications
+- Modular structure with dependency injection
+- Comprehensive testing setup
+- Docker-ready deployments
+- CLI tools for rapid development
+
+## ✅ Requirements
+
+- Python 3.10+
+
+## 📦 Installation
+
+```bash
+pip install rapidkit-core
+```
+
+```bash
+pip install --pre rapidkit-core
+```
+
+## 🛠️ Usage
+
+```bash
+rapidkit create myapp
+cd myapp
+rapidkit info
+```
+
+## 📚 Documentation
+
+For detailed documentation, visit our docs.
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our contributing guide.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+

rapidkit_core-0.1.2rc2/README.md

@@ -0,0 +1,47 @@
+# RapidKit Community-staging
+
+Public staging playground where we polish the next wave of RapidKit magic together
+
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 🚀 Features
+
+- Clean Architecture FastAPI applications
+- Modular structure with dependency injection
+- Comprehensive testing setup
+- Docker-ready deployments
+- CLI tools for rapid development
+
+## ✅ Requirements
+
+- Python 3.10+
+
+## 📦 Installation
+
+```bash
+pip install rapidkit-core
+```
+
+```bash
+pip install --pre rapidkit-core
+```
+
+## 🛠️ Usage
+
+```bash
+rapidkit create myapp
+cd myapp
+rapidkit info
+```
+
+## 📚 Documentation
+
+For detailed documentation, visit our docs.
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our contributing guide.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

rapidkit_core-0.1.2rc2/pyproject.toml

@@ -0,0 +1,151 @@
+[tool.poetry]
+name = "rapidkit-core"
+version = "0.1.2rc2"
+description = "Public staging playground where we polish the next wave of RapidKit magic together"
+authors = ["RapidKit Team <team@rapidkit.com>"]
+readme = "README.md"
+license = "MIT"
+homepage = "https://github.com/getrapidkit/community-staging"
+repository = "https://github.com/getrapidkit/community-staging"
+keywords = ["scaffolding", "boilerplate", "fastapi", "codegen", "devtools"]
+classifiers = [
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Code Generators",
+  "Development Status :: 4 - Beta",
+]
+
+packages = [
+  { include = "core", from = "src" },
+  { include = "cli", from = "src" },
+  { include = "kits", from = "src" },
+  { include = "modules", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+# Align CLI runtime with engine defaults for compatibility
+typer = ">=0.19,<0.20"
+click = ">=8.3,<8.4"
+rich = "^14.2.0"
+pyyaml = "^6.0.3"
+tabulate = "^0.9.0"
+jsonschema = "^4.25.1"
+jinja2 = "^3.1.6"
+pydantic = ">=2.12.2"
+pydantic-settings = ">=2.11,<3.0"
+pynacl = "^1.5.0"
+cryptography = "^46.0.2"
+types-requests = "^2.32.4.20250913"
+requests = "^2.32.5"
+email-validator = ">=2.1,<3.0"
+pygithub = "^2.7.0"
+packaging = "^25.0"
+black = "^25.9.0"
+yamllint = "^1.37.1"
+fastapi = ">=0.119.0,<1.0.0"
+starlette = ">=0.49.1,<0.50"
+uvicorn = { version = ">=0.37.0", extras = ["standard"] }
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.2"
+pytest-cov = "^7.0.0"
+pytest-asyncio = "^0.23.8"
+black = "^25.9.0"
+ruff = "^0.14.0"
+mypy = "^1.18.2"
+types-PyYAML = "^6.0.12.20250915"
+pip-audit = "^2.9.0"
+bandit = "^1.8.6"
+pre-commit = "^4.3.0"
+types-requests = "^2.32.4.20250913"
+cryptography = "^46.0.2"
+httpx = "^0.28.0"
+
+[tool.poetry.scripts]
+rapidkit = "cli.global_cli:main"
+
+[tool.coverage.run]
+branch = false
+source = ["src"]
+omit = [
+  "src/core/quantum_engine.py",
+  "src/experimental/*",
+  "*/tests/*",
+  "*/test_*",
+  "*/conftest.py",
+  "*/__pycache__/*",
+  "*/migrations/*",
+  "*/venv/*",
+  "*/env/*",
+  "*/.venv/*",
+  "*/.env/*",
+    "*/templates/*",
+    "*/pytest-of-*/*",
+]
+
+[tool.coverage.report]
+skip_empty = true
+show_missing = false
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]
+
+[tool.coverage.excluded_files]
+patterns = [
+    "*/templates/*",
+    "*/migrations/*",
+    "*_pb2.py",
+    "*/experimental/*",
+]
+[tool.mypy]
+python_version = "3.10"
+mypy_path = "src"
+warn_unused_configs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_return_any = true
+warn_unreachable = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+show_error_codes = true
+pretty = true
+packages = ["core", "cli", "kits", "modules"]
+explicit_package_bases = true
+namespace_packages = true
+follow_imports = "normal"
+exclude = [
+    "tests/",
+    "user-tests/",
+    "src/experimental/",
+]
+
+[[tool.mypy.overrides]]
+module = [
+    "cli.ui.printer",
+    "core.kit_utils",
+    "core.services.snippet_injector",
+    "cli.commands.add.module",
+    "core.tui",
+    "requests.*",
+    "jsonschema.*",
+    "yaml.*"
+]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = [
+  "psutil.*",
+  "nacl.*"
+]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

rapidkit_core-0.1.2rc2/src/cli/__init__.py

@@ -0,0 +1,27 @@
+"""CLI package exports."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+__all__ = ["global_cli"]
+
+if TYPE_CHECKING:  # pragma: no cover - type hints only
+    global_cli: Any
+
+
+def __getattr__(name: str) -> Any:
+    if name != "global_cli":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    try:
+        module = importlib.import_module(".global_cli", __name__)
+    except ModuleNotFoundError:
+        module = importlib.import_module(".main", __name__)
+    globals()[name] = module
+    return module
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals().keys(), *__all__})

rapidkit_core-0.1.2rc2/src/cli/_compat.py

@@ -0,0 +1,74 @@
+"""Minimal compatibility shim for Typer help rendering.
+
+We avoid patching Click/Typer internals. Dependency pins ensure
+compatibility and here we just disable rich/markup to keep help stable.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from typing import Any, Callable, Optional, cast
+
+# Disable Typer's rich help when Typer is present; this avoids invoking
+# rich-driven helpers that may exercise varying internal signatures.
+with contextlib.suppress(ImportError):
+    import typer
+
+    with contextlib.suppress(AttributeError):
+        typer.rich = None  # type: ignore[attr-defined]
+
+    # Also try to disable rich integration completely
+    with contextlib.suppress(AttributeError):
+        typer.core.rich = None  # type: ignore
+
+    # Try to disable rich console integration by setting environment variables
+    with contextlib.suppress(AttributeError, ImportError):
+        import os
+
+        os.environ["NO_COLOR"] = "1"
+        os.environ["TERM"] = "dumb"
+
+with contextlib.suppress(ImportError):
+    import click
+
+    _sanitize_console_text: Optional[Callable[[str], str]]
+
+    try:
+        from .ui.printer import sanitize_console_text as _sanitize_console_text
+    except ImportError:
+        _sanitize_console_text = None
+    else:
+        _click_echo = click.utils.echo
+
+        def _safe_echo(
+            message: Any = None,
+            file: Any = None,
+            nl: bool = True,
+            err: bool = False,
+            color: Any = None,
+            **kwargs: Any,
+        ) -> Any:
+            if isinstance(message, str) and _sanitize_console_text is not None:
+                message = _sanitize_console_text(message)
+            return _click_echo(
+                message=message,
+                file=file,
+                nl=nl,
+                err=err,
+                color=color,
+                **kwargs,
+            )
+
+        click.utils.echo = _safe_echo
+        click.echo = _safe_echo
+
+        with contextlib.suppress(ImportError):
+            import click.decorators as _click_decorators
+
+            cast(Any, _click_decorators).echo = _safe_echo
+
+        with contextlib.suppress(ImportError):
+            import click.termui as _click_termui
+
+            cast(Any, _click_termui).echo = _safe_echo
+__all__ = ["Any", "Optional", "cast"]

rapidkit_core-0.1.2rc2/src/cli/commands/__init__.py

@@ -0,0 +1,20 @@
+from .create import create_app, create_project
+from .diff import diff_app
+from .info import info
+from .license import license_app
+from .list import list_kits
+from .rollback import rollback_app
+from .uninstall import uninstall_app
+from .upgrade import upgrade_app
+
+__all__ = [
+    "create_app",
+    "create_project",
+    "diff_app",
+    "info",
+    "license_app",
+    "list_kits",
+    "rollback_app",
+    "uninstall_app",
+    "upgrade_app",
+]

rapidkit_core-0.1.2rc2/src/cli/commands/add/__init__.py

@@ -0,0 +1,16 @@
+# src/cli/commands/add/__init__.py
+import typer
+
+from .all import all_app
+
+# Import the module command and the 'all' sub-typer
+from .module import add_module
+
+# Compose a single add_app Typer that exposes the module command and the 'all' sub-typer
+add_app = typer.Typer(help="➕ Add components like modules, resources, etc.")
+
+# Direct command: `rapidkit add module <name>` (backwards compatible)
+add_app.command("module")(add_module)
+
+# Sub-typer: `rapidkit add all module ...`
+add_app.add_typer(all_app, name="all")

rapidkit_core-0.1.2rc2/src/cli/commands/add/all.py

@@ -0,0 +1,217 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+import typer
+
+from core.services.config_loader import load_module_config
+
+from ...ui.printer import print_error, print_info, print_success, print_warning
+
+# from ....core.services.config_loader import load_module_config
+# from ...ui.printer import print_error, print_info, print_success, print_warning
+from .module import add_module as invoke_add_module
+
+try:  # optional dependency
+    import yaml
+except (ImportError, OSError):  # pragma: no cover - optional dependency
+    yaml = None  # type: ignore[assignment]
+
+all_app = typer.Typer()
+
+
+def _module_priority(name: str, config: Dict[str, Any]) -> int:
+    # Allow explicit priority in module config
+    if "priority" in config:
+        p = config["priority"]
+        if isinstance(p, int):
+            return p
+    elif "meta" in config and "priority" in config["meta"]:
+        p = config["meta"]["priority"]
+        if isinstance(p, int):
+            return p
+
+    # heuristic priorities
+    n = name.lower()
+    if "settings" in n:
+        return 0
+    if "postgres" in n or "postgresql" in n or n == "db":
+        return 10
+    if "redis" in n:
+        return 20
+    return 50
+
+
+@all_app.command("module")
+def add_all(
+    profile: str = typer.Option("fastapi/standard", help="Target profile"),
+    project: str = typer.Option(None, help="Project name inside boilerplates"),
+    final: bool = typer.Option(False, "--final", help="Remove inject anchors for production"),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation prompts"),
+    report: str = typer.Option("add_all_report.json", help="Report filename"),
+) -> None:
+    """Install all modules that apply to a given profile in priority order.
+
+    Usage: rapidkit add all module --profile fastapi/enterprise --project xxx
+    """
+    # Resolve repo root robustly (4 levels above this file)
+    repo_root = Path(__file__).resolve().parents[4]
+    modules_path = repo_root / "src" / "modules"
+    project_root = repo_root / "boilerplates" / (project or "test")
+    if not project_root.exists():
+        print_error(f"❌ Project root not found: {project_root}")
+        raise typer.Exit(1)
+
+    print_info(f"🔍 Locating modules for profile {profile}")
+    candidates = []
+
+    # 1) Prefer a modules index (JSON/YAML) if present to honor curated sets and order
+    index_candidates = [
+        repo_root / "modules_index.json",
+        repo_root / "kit_modules.json",
+        repo_root / "config" / "kit_modules.yaml",
+        repo_root / "config" / "kit_modules.yml",
+    ]
+    index_path = next((p for p in index_candidates if p.exists()), None)
+
+    ordered_names: List[str] = []
+    if index_path:
+        print_info(f"🔍 Loading modules index: {index_path}")
+        try:
+            if index_path.suffix in (".yaml", ".yml"):
+                data = (
+                    yaml.safe_load(index_path.read_text(encoding="utf-8")) if yaml else {}
+                ) or {}
+            else:
+                data = json.loads(index_path.read_text(encoding="utf-8")) or {}
+        except (OSError, json.JSONDecodeError, AttributeError) as e:
+            print_warning(f"⚠️ Failed to read/parse modules index: {e}")
+            data = {}
+
+        # Support both legacy flat mapping and new schema with 'kits'
+        kits = (data or {}).get("kits") or {}
+        kit_spec = kits.get(profile)
+        if not kit_spec:
+            # try by kit name (e.g., fastapi) or other fallbacks
+            kit_name = profile.split("/")[0]
+            kit_spec = kits.get(kit_name)
+
+        if kit_spec:
+            # Build ordered list: recommended_install_order then remaining modules
+            reco = kit_spec.get("recommended_install_order") or []
+            listed = kit_spec.get("modules") or []
+            # normalize to list[str]
+            reco = [x for x in reco if isinstance(x, str)]
+            listed = [x for x in listed if isinstance(x, str)]
+            ordered_names = reco + [m for m in listed if m not in reco]
+        else:
+            # legacy: top-level mapping { profile: [modules...] }
+            legacy_list = (data or {}).get(profile)
+            if not legacy_list:
+                kit_name = profile.split("/")[0]
+                legacy_list = (data or {}).get(kit_name) or (data or {}).get("default")
+            if isinstance(legacy_list, list):
+                ordered_names = [x if isinstance(x, str) else x.get("name") for x in legacy_list]
+                ordered_names = [x for x in ordered_names if x]
+
+    # 2) If we have an ordered list from index, try to load those; otherwise scan filesystem
+    if ordered_names:
+        print_info(
+            f"🧭 Using curated module list for {profile} from index ({len(ordered_names)} items)"
+        )
+        for name in ordered_names:
+            try:
+                cfg = load_module_config(name, profile)
+                candidates.append((name, cfg))
+            except (FileNotFoundError, OSError, json.JSONDecodeError) as e:
+                print_warning(f"⚠️ Skipping module {name} from index: could not load config ({e})")
+                continue
+    else:
+        if not modules_path.exists():
+            print_error(
+                f"❌ No curated index available and modules directory not found: {modules_path}"
+            )
+            raise typer.Exit(1)
+        print_info(f"🔍 Scanning modules in {modules_path} for profile {profile}")
+        for d in modules_path.iterdir():
+            if not d.is_dir():
+                continue
+            name = d.name
+            try:
+                cfg = load_module_config(name, profile)
+            except (FileNotFoundError, OSError, json.JSONDecodeError) as e:
+                print_warning(f"⚠️ Skipping module {name}: could not load config ({e})")
+                continue
+            # determine if module supports profile by explicit profiles key or features
+            supports = False
+            profiles_map = cfg.get("profiles", {}) or {}
+            if profile in profiles_map:
+                supports = True
+            else:
+                # check features entries for profile membership
+                for feat in cfg.get("features", {}).values():
+                    if isinstance(feat, dict) and profile in feat.get("profiles", []):
+                        supports = True
+                        break
+
+            if supports:
+                candidates.append((name, cfg))
+
+    if not candidates:
+        print_warning("⚠️ No modules found for this profile")
+        raise typer.Exit(0)
+
+    # sort by priority: if we used index order, keep it; otherwise use heuristic
+    if ordered_names:
+        order_index = {name: i for i, name in enumerate(ordered_names)}
+        candidates.sort(key=lambda it: order_index.get(it[0], 10_000))
+    else:
+        candidates.sort(key=lambda it: _module_priority(it[0], it[1]))
+
+    print_info(f"⚙️ Will attempt to install {len(candidates)} modules in order")
+    for idx, (n, _) in enumerate(candidates, start=1):
+        print_info(f"  {idx}. {n}")
+
+    if not yes:
+        if not typer.confirm("Proceed to install these modules? (y/N)"):
+            print_info("Aborted by user")
+            raise typer.Exit(0)
+
+    report_entries = []
+    for name, _cfg in candidates:  # _cfg unused; kept tuple structure
+        entry = {"module": name, "status": "pending", "error": None}
+        try:
+            # call the add module function programmatically
+            invoke_add_module(
+                name,
+                profile=profile,
+                project=project,
+                final=final,
+                with_deps=True,
+            )
+            entry["status"] = "installed"
+            print_success(f"✅ Installed module: {name}")
+        except (OSError, RuntimeError) as e:
+            entry["status"] = "failed"
+            entry["error"] = str(e)
+            print_warning(f"❌ Failed to install {name}: {e}")
+        report_entries.append(entry)
+
+    # Build report data without shadowing the filename option 'report'
+    report_data = {
+        "profile": profile,
+        "project": project or "test",
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "results": report_entries,
+    }
+
+    # Defensive: user might have passed something weird or internal shadowing occurred earlier
+    report_filename = str(report)
+
+    report_path = project_root / report_filename
+    try:
+        report_path.write_text(json.dumps(report_data, indent=2), encoding="utf-8")
+        print_success(f"📄 Report written: {report_path}")
+    except OSError as e:
+        print_warning(f"⚠️ Could not write report file: {e}")