djangoplay-cli 1.0.0__tar.gz

djangoplay_cli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 binaryfleet chandrashekhar-bhosale
+
+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.

djangoplay_cli-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: djangoplay-cli
+Version: 1.0.0
+Summary: CLI tools for DjangoPlay developers. 'djangoplay-cli' provides a lightweight command-line interface for developers working on the 'DjangoPlay ecosystem'.
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file

djangoplay_cli-1.0.0/README.md

@@ -0,0 +1,334 @@
+# djangoplay-cli
+
+![Python](https://img.shields.io/badge/python-3.11%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Lint](https://img.shields.io/badge/lint-ruff-informational)
+![Formatting](https://img.shields.io/badge/format-ruff-informational)
+
+**djangoplay-cli** is a developer command-line interface for managing local
+development environments within the **DjangoPlay ecosystem**.
+
+The CLI simplifies common developer workflows such as:
+
+- starting the development server
+- managing Celery workers
+- validating environment dependencies
+- resetting development services
+- orchestrating local development processes
+
+The goal is to provide a **simple, predictable, and portable developer tool**
+without introducing complex infrastructure dependencies.
+
+---
+
+# Philosophy
+
+This project follows several guiding principles:
+
+* **Minimal configuration**
+* **No secrets in the repository**
+* **Clear command structure**
+* **Stable developer experience**
+* **Incremental releases**
+* **Developer-first ergonomics**
+
+The CLI is designed to remove repetitive setup tasks so developers can focus
+on application development instead of environment management.
+
+---
+
+# Supported Platforms
+
+| Platform | Status |
+|--------|--------|
+| macOS | Supported |
+| Linux | Supported |
+| Ubuntu | Supported |
+| Windows (WSL) | Supported |
+| Windows native | Limited |
+
+---
+
+# Installation
+
+Install from PyPI:
+
+```bash
+pip install djangoplay-cli
+````
+
+Verify installation:
+
+```bash
+dplay --version
+```
+
+Example output:
+
+```
+1.0.0
+```
+
+---
+
+# CLI Overview
+
+The CLI is organized into command groups.
+
+```
+dplay
+ ├── dev
+ │    ├── http
+ │    ├── ssl
+ │    ├── worker
+ │    ├── up
+ │    └── down
+ │
+ ├── system
+ │    ├── doctor
+ │    └── reset
+ │
+ └── logs
+```
+
+---
+
+# Development Commands
+
+These commands manage the Django development environment.
+
+### Start HTTP development server
+
+```
+dplay dev http
+```
+
+Starts:
+
+* Celery worker
+* Celery beat
+* Django development server
+
+Server URL:
+
+```
+http://localhost:3333
+```
+
+---
+
+### Start HTTPS development server
+
+```
+dplay dev ssl
+```
+
+Uses `runserver_plus` when available.
+
+Server URL:
+
+```
+https://localhost:9999
+```
+
+---
+
+### Start Celery worker
+
+```
+dplay dev worker
+```
+
+Starts the Celery worker for the DjangoPlay application.
+
+---
+
+### Start full development environment
+
+```
+dplay dev up
+```
+
+Starts all development services including:
+
+* Celery worker
+* Celery beat
+* Django development server
+
+---
+
+### Stop development services
+
+```
+dplay dev down
+```
+
+Stops running Celery processes and development services.
+
+---
+
+# System Commands
+
+System commands validate and reset the development environment.
+
+### Run environment diagnostics
+
+```
+dplay system doctor
+```
+
+Checks:
+
+* Python version
+* Redis availability
+* PostgreSQL availability
+* Celery installation
+
+Example output:
+
+```
+Environment Diagnostics
+
+✔ Python version OK
+✔ Redis reachable
+✔ Postgres reachable
+✔ Celery available
+```
+
+---
+
+### Reset development environment
+
+```
+dplay system reset
+```
+
+Actions performed:
+
+* stop running Celery workers
+* stop Celery beat processes
+* flush Redis cache
+
+---
+
+# Logs
+
+Display development logs.
+
+```
+dplay logs
+```
+
+(Currently reserved for future improvements.)
+
+---
+
+# CLI Help
+
+Show CLI help:
+
+```
+dplay --help
+```
+
+Show development commands:
+
+```
+dplay dev --help
+```
+
+Show system commands:
+
+```
+dplay system --help
+```
+
+---
+
+# Project Structure
+
+```
+djangoplay-cli/
+
+dplay/
+  commands/
+  core/
+  environment/
+  utils/
+```
+
+### Architecture Layers
+
+| Layer        | Responsibility                   |
+| ------------ | -------------------------------- |
+| CLI Commands | user-facing commands             |
+| Core         | repository and service detection |
+| Environment  | environment validation           |
+| Utils        | reusable helpers                 |
+
+This modular architecture keeps the CLI maintainable as new features are added.
+
+---
+
+# Development Setup
+
+Clone repository:
+
+```
+git clone https://github.com/binaryfleet/djangoplay-cli.git
+cd djangoplay-cli
+```
+
+Install in editable mode:
+
+```
+pip install -e .
+```
+
+Install development tools:
+
+```
+pip install ruff pytest
+```
+
+Run lint checks:
+
+```
+ruff check .
+```
+
+Run tests:
+
+```
+pytest
+```
+
+---
+
+# Security Principles
+
+This project follows strict security practices:
+
+* no credentials stored in the repository
+* secrets must remain in local environment files
+* CLI never generates secrets automatically
+* CLI never writes credentials to disk
+
+---
+
+# Versioning
+
+This project follows **Semantic Versioning**.
+
+```
+v0.x  → experimental development
+v1.x  → stable production releases
+```
+
+---
+
+# License
+
+This project is licensed under the **MIT License**.
+
+See the [LICENSE](LICENSE) file for details.

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: djangoplay-cli
+Version: 1.0.0
+Summary: CLI tools for DjangoPlay developers. 'djangoplay-cli' provides a lightweight command-line interface for developers working on the 'DjangoPlay ecosystem'.
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+LICENSE
+README.md
+pyproject.toml
+djangoplay_cli.egg-info/PKG-INFO
+djangoplay_cli.egg-info/SOURCES.txt
+djangoplay_cli.egg-info/dependency_links.txt
+djangoplay_cli.egg-info/entry_points.txt
+djangoplay_cli.egg-info/requires.txt
+djangoplay_cli.egg-info/top_level.txt
+dplay/__init__.py
+dplay/cli.py
+dplay/commands/__init__.py
+dplay/commands/dev/__init__.py
+dplay/commands/dev/down.py
+dplay/commands/dev/http.py
+dplay/commands/dev/logs.py
+dplay/commands/dev/ssl.py
+dplay/commands/dev/up.py
+dplay/commands/dev/worker.py
+dplay/commands/system/__init__.py
+dplay/commands/system/doctor.py
+dplay/commands/system/reset.py
+dplay/core/__init__.py
+dplay/core/config_loader.py
+dplay/core/process_manager.py
+dplay/core/repo_detector.py
+dplay/environment/__init__.py
+dplay/environment/diagnostics.py
+dplay/environment/venv_detector.py
+dplay/utils/__init__.py
+dplay/utils/dev_startup.py
+dplay/utils/subprocess_utils.py

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dplay = dplay.cli:main

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer>=0.9
+rich>=13
+pyyaml>=6.0

djangoplay_cli-1.0.0/djangoplay_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+dplay

djangoplay_cli-1.0.0/dplay/__init__.py

@@ -0,0 +1,8 @@
+"""
+DjangoPlay CLI package.
+
+This package provides developer tooling used by the
+DjangoPlay ecosystem.
+
+Version: 1.0.0
+"""

djangoplay_cli-1.0.0/dplay/cli.py

@@ -0,0 +1,99 @@
+"""
+CLI entrypoint for djangoplay-cli.
+
+This module defines the root CLI application and registers
+all command groups.
+"""
+
+from importlib.metadata import version
+
+import typer
+
+from dplay.commands.dev.down import down_command
+from dplay.commands.dev.http import http_command
+from dplay.commands.dev.logs import logs_command
+from dplay.commands.dev.ssl import ssl_command
+from dplay.commands.dev.up import up_command
+from dplay.commands.dev.worker import worker_command
+from dplay.commands.system.doctor import doctor_command
+from dplay.commands.system.reset import reset_command
+
+app = typer.Typer(help="DjangoPlay CLI")
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+
+
+def get_cli_version() -> str:
+    """
+    Retrieve CLI version from installed package metadata.
+    """
+
+    try:
+        return version("djangoplay-cli")
+    except Exception:
+        return "unknown"
+
+
+# ------------------------------------------------------------------
+# DEV COMMAND GROUP
+# ------------------------------------------------------------------
+
+dev_app = typer.Typer(help="Development commands")
+
+dev_app.command("http")(http_command)
+dev_app.command("ssl")(ssl_command)
+dev_app.command("worker")(worker_command)
+dev_app.command("up")(up_command)
+dev_app.command("down")(down_command)
+
+app.add_typer(dev_app, name="dev")
+
+# ------------------------------------------------------------------
+# SYSTEM COMMAND GROUP
+# ------------------------------------------------------------------
+
+system_app = typer.Typer(help="System environment commands")
+
+system_app.command("doctor")(doctor_command)
+system_app.command("reset")(reset_command)
+
+app.add_typer(system_app, name="system")
+
+# ------------------------------------------------------------------
+# LOG COMMAND
+# ------------------------------------------------------------------
+
+app.command("logs")(logs_command)
+
+# -------------------------------------------------------------
+# GLOBAL OPTIONS
+# ------------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def callback(
+    ctx: typer.Context,
+    version_flag: bool = typer.Option(None, "--version", "-v", is_eager=True),
+):
+    """
+    CLI entrypoint used by the console script.
+
+    This wrapper ensures compatibility with Python packaging
+    and avoids exposing the Typer object directly and handles
+    global CLI option such as --version.
+    """
+
+    if version_flag:
+        typer.echo(get_cli_version())
+        raise typer.Exit()
+
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+def main():
+    app()

djangoplay_cli-1.0.0/dplay/commands/__init__.py

@@ -0,0 +1,15 @@
+"""
+CLI command packages for djangoplay-cli.
+
+This module groups all user-facing CLI commands exposed
+through the `dplay` command-line interface.
+
+Submodules implement command groups such as:
+
+- dev
+- env (future)
+- repo (future)
+
+The command structure follows the Typer CLI architecture
+defined in `dplay.cli`.
+"""

djangoplay_cli-1.0.0/dplay/commands/dev/__init__.py

@@ -0,0 +1,25 @@
+"""
+Development command group for djangoplay-cli.
+
+This package contains CLI commands responsible for managing
+the local DjangoPlay development environment.
+
+Available commands include:
+
+- dev http     → start Django development server (HTTP)
+- dev ssl      → start Django development server (HTTPS)
+- dev worker   → start Celery worker
+- dev up       → start full development environment
+- dev down     → stop development environment
+- dev logs     → display development logs
+
+The commands in this package coordinate services such as:
+
+- Django development server
+- Celery worker and beat
+- Redis
+- PostgreSQL
+
+These commands are registered under the `dplay dev` command
+group defined in `dplay.cli`.
+"""

djangoplay_cli-1.0.0/dplay/commands/dev/down.py

@@ -0,0 +1,20 @@
+"""
+Stop development environment.
+"""
+
+from dplay.core.process_manager import stop_celery
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def down_command():
+    """
+    Stop all development services.
+    """
+
+    print("Stopping DjangoPlay services")
+
+    stop_celery()
+
+    print("Services stopped")

djangoplay_cli-1.0.0/dplay/commands/dev/http.py

@@ -0,0 +1,42 @@
+"""
+HTTP development server command.
+"""
+
+import subprocess
+
+from dplay.core.repo_detector import ensure_repo
+from dplay.environment.venv_detector import ensure_venv
+from dplay.utils.dev_startup import print_environment, restart_celery
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def http_command():
+    """
+    Start DjangoPlay HTTP development server.
+
+    Starts:
+    - Celery worker
+    - Celery beat
+    - Django development server
+    """
+
+    repo_path = ensure_repo()
+    python_exec = ensure_venv()
+
+    print_environment(repo_path, python_exec)
+
+    restart_celery()
+
+    print("✔ Django server starting\n")
+
+    print("Server URL:")
+    print("http://localhost:3333\n")
+
+    print("Press CTRL+C to stop the server.\n")
+
+    subprocess.run(
+        ["python", "manage.py", "runserver", "localhost:3333"],
+        check=True,
+    )

djangoplay_cli-1.0.0/dplay/commands/dev/logs.py

@@ -0,0 +1,14 @@
+"""
+CLI log command.
+"""
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def logs_command():
+    """
+    Display development logs.
+    """
+
+    print("Logs feature coming soon")

djangoplay_cli-1.0.0/dplay/commands/dev/ssl.py

@@ -0,0 +1,43 @@
+"""
+HTTPS development server command.
+"""
+
+import subprocess
+
+from dplay.core.repo_detector import ensure_repo
+from dplay.environment.venv_detector import ensure_venv
+from dplay.utils.dev_startup import print_environment, restart_celery
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def ssl_command():
+    """
+    Start DjangoPlay HTTPS development server.
+
+    Uses runserver_plus when available.
+    """
+
+    repo_path = ensure_repo()
+    python_exec = ensure_venv()
+
+    print_environment(repo_path, python_exec)
+
+    restart_celery()
+
+    print("✔ Django HTTPS server starting\n")
+
+    print("Server URL:")
+    print("https://localhost:9999\n")
+
+    try:
+        subprocess.run(
+            ["python", "manage.py", "runserver_plus", "localhost:9999"],
+            check=True,
+        )
+    except Exception:
+        subprocess.run(
+            ["python", "manage.py", "runserver", "localhost:9999"],
+            check=True,
+        )

djangoplay_cli-1.0.0/dplay/commands/dev/up.py

@@ -0,0 +1,24 @@
+"""
+Start full development environment.
+"""
+
+import subprocess
+
+from dplay.core.process_manager import start_celery
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def up_command():
+    """
+    Start Redis, Celery and Django services.
+    """
+
+    print("Starting DjangoPlay development environment\n")
+
+    start_celery()
+
+    subprocess.Popen(["python", "manage.py", "runserver", "localhost:3333"])
+
+    print("Environment is up")

djangoplay_cli-1.0.0/dplay/commands/dev/worker.py

@@ -0,0 +1,25 @@
+"""
+Celery worker command.
+"""
+
+import subprocess
+
+from dplay.core.repo_detector import ensure_repo
+from dplay.environment.venv_detector import ensure_venv
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def worker_command():
+    """
+    Start Celery worker and beat services.
+    """
+
+    ensure_repo()
+    ensure_venv()
+
+    subprocess.run(
+        ["celery", "-A", "paystream", "worker", "-l", "info"],
+        check=True,
+    )

djangoplay_cli-1.0.0/dplay/commands/system/__init__.py

@@ -0,0 +1,3 @@
+"""
+DjangoPlay CLI Health Diagnostics
+"""

djangoplay_cli-1.0.0/dplay/commands/system/doctor.py

@@ -0,0 +1,31 @@
+"""
+Environment diagnostics command.
+"""
+
+from dplay.core.repo_detector import ensure_repo
+from dplay.environment.diagnostics import run_diagnostics
+from dplay.environment.venv_detector import ensure_venv
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def doctor_command():
+    """
+    Run environment diagnostics.
+    """
+
+    ensure_repo()
+    ensure_venv()
+
+    print("\nEnvironment Diagnostics\n")
+
+    results = run_diagnostics()
+
+    for ok, message in results:
+        if ok:
+            print(f"✔ {message}")
+        else:
+            print(f"✖ {message}")
+
+    print("")

djangoplay_cli-1.0.0/dplay/commands/system/reset.py

@@ -0,0 +1,37 @@
+"""
+Environment reset command.
+"""
+
+import subprocess
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def reset_command():
+    """
+    Reset development environment.
+    """
+
+    print("\nResetting development environment\n")
+
+    subprocess.run(
+        'pkill -9 -f "celery.*paystream" 2>/dev/null || true',
+        shell=True,
+    )
+
+    subprocess.run(
+        'pkill -9 -f "celery.*beat" 2>/dev/null || true',
+        shell=True,
+    )
+
+    print("✔ Celery processes stopped")
+
+    subprocess.run(
+        "redis-cli flushall",
+        shell=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    print("✔ Redis flushed\n")

djangoplay_cli-1.0.0/dplay/core/__init__.py

@@ -0,0 +1,12 @@
+"""
+Core infrastructure utilities for djangoplay-cli.
+
+This package contains low-level helpers responsible for:
+
+- repository detection
+- process management (future)
+- configuration loading (future)
+
+Core modules should remain lightweight and reusable
+across CLI commands.
+"""

djangoplay_cli-1.0.0/dplay/core/config_loader.py

@@ -0,0 +1,53 @@
+"""
+Configuration loader for DjangoPlay CLI.
+
+Loads configuration from ~/.dplay/config.yaml
+and secrets from ~/.dplay/.secrets
+"""
+
+import os
+from pathlib import Path
+
+import yaml
+
+CONFIG_DIR = Path.home() / ".dplay"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+SECRETS_FILE = CONFIG_DIR / ".secrets"
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def load_config():
+    """
+    Load YAML configuration file.
+    """
+
+    if not CONFIG_FILE.exists():
+        raise RuntimeError("Missing configuration file ~/.dplay/config.yaml")
+
+    with open(CONFIG_FILE) as f:
+        return yaml.safe_load(f)
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def load_secrets():
+    """
+    Load secrets into environment variables.
+    """
+
+    if not SECRETS_FILE.exists():
+        return
+
+    with open(SECRETS_FILE) as f:
+        for line in f:
+            line = line.strip()
+
+            if not line or line.startswith("#"):
+                continue
+
+            key, value = line.split("=", 1)
+
+            os.environ[key] = value

djangoplay_cli-1.0.0/dplay/core/process_manager.py

@@ -0,0 +1,37 @@
+"""
+Process management utilities.
+"""
+
+import subprocess
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def start_celery():
+    """
+    Start celery worker and beat.
+    """
+
+    subprocess.Popen(["celery", "-A", "paystream", "worker", "-l", "info"])
+
+    subprocess.Popen(["celery", "-A", "paystream", "beat", "-l", "info"])
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def stop_celery():
+    """
+    Stop running celery workers.
+    """
+
+    subprocess.run(
+        'pkill -9 -f "celery.*paystream" 2>/dev/null || true',
+        shell=True,
+    )
+
+    subprocess.run(
+        'pkill -9 -f "celery.*beat" 2>/dev/null || true',
+        shell=True,
+    )

djangoplay_cli-1.0.0/dplay/core/repo_detector.py

@@ -0,0 +1,40 @@
+"""
+Repository detection utilities.
+"""
+
+import subprocess
+import sys
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def ensure_repo():
+    """
+    Ensure command runs inside DjangoPlay repository.
+
+    Returns
+    -------
+    str
+        Repository root path.
+    """
+
+    try:
+        result = subprocess.check_output(
+            ["git", "rev-parse", "--show-toplevel"],
+            stderr=subprocess.DEVNULL,
+        )
+
+        repo_path = result.decode().strip()
+
+        if "djangoplay" not in repo_path.lower():
+            raise RuntimeError
+
+        return repo_path
+
+    except Exception:
+        print(
+            "Error: DjangoPlay repository not detected.\n"
+            "Run this command inside the DjangoPlay project directory."
+        )
+        sys.exit(1)

djangoplay_cli-1.0.0/dplay/environment/__init__.py

@@ -0,0 +1,15 @@
+"""
+Environment validation utilities.
+
+Modules in this package verify the runtime environment
+required to execute DjangoPlay development commands.
+
+Current responsibilities include:
+
+- Python virtual environment validation
+
+Future responsibilities may include:
+
+- dependency checks
+- system diagnostics
+"""

djangoplay_cli-1.0.0/dplay/environment/diagnostics.py

@@ -0,0 +1,79 @@
+"""
+Environment diagnostics utilities.
+"""
+
+import shutil
+import socket
+import sys
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def check_python():
+    """Verify Python version."""
+
+    version = sys.version_info
+    if version.major >= 3 and version.minor >= 11:
+        return True, "Python version OK"
+    return False, "Python >=3.11 required"
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def check_redis():
+    """Check Redis availability."""
+
+    try:
+        sock = socket.create_connection(("127.0.0.1", 6379), timeout=1)
+        sock.close()
+        return True, "Redis reachable"
+    except Exception:
+        return False, "Redis not reachable"
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def check_postgres():
+    """Check Postgres availability."""
+
+    try:
+        sock = socket.create_connection(("127.0.0.1", 5432), timeout=1)
+        sock.close()
+        return True, "Postgres reachable"
+    except Exception:
+        return False, "Postgres not reachable"
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def check_celery():
+    """Check Celery availability."""
+
+    if shutil.which("celery"):
+        return True, "Celery available"
+    return False, "Celery not installed"
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def run_diagnostics():
+    """Run all environment checks."""
+
+    checks = [
+        check_python,
+        check_redis,
+        check_postgres,
+        check_celery,
+    ]
+
+    results = []
+
+    for check in checks:
+        results.append(check())
+
+    return results

djangoplay_cli-1.0.0/dplay/environment/venv_detector.py

@@ -0,0 +1,26 @@
+"""
+Virtual environment detection utilities.
+"""
+
+import os
+import sys
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def ensure_venv():
+    """
+    Ensure Python virtual environment is active.
+
+    Returns
+    -------
+    str
+        Python executable path.
+    """
+
+    if "VIRTUAL_ENV" not in os.environ:
+        print("Error: Virtual environment not active.")
+        sys.exit(1)
+
+    return sys.executable

djangoplay_cli-1.0.0/dplay/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+Utility helpers used across the CLI implementation.
+
+These modules provide reusable functionality such as:
+
+- development startup helpers
+- subprocess wrappers
+- future CLI utilities
+"""

djangoplay_cli-1.0.0/dplay/utils/dev_startup.py

@@ -0,0 +1,66 @@
+"""
+Development startup helpers.
+
+Shared utilities used by development commands such as:
+
+- dev http
+- dev ssl
+"""
+
+import subprocess
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def print_environment(repo_path: str, python_exec: str):
+    """
+    Print CLI environment summary.
+    """
+
+    print("\nDjangoPlay CLI\n")
+
+    print(f"Repository:   {repo_path}")
+    print(f"Python:       {python_exec}")
+    print("Environment:  development\n")
+
+
+# ------------------------------------------------------------------
+# EXTENSIBLE METADATA
+# ------------------------------------------------------------------
+def restart_celery():
+    """
+    Stop existing celery processes and start fresh ones.
+    """
+
+    print("Stopping existing Celery workers...")
+
+    subprocess.run(
+        'pkill -9 -f "celery.*paystream" 2>/dev/null || true',
+        shell=True,
+    )
+
+    subprocess.run(
+        'pkill -9 -f "celery.*beat" 2>/dev/null || true',
+        shell=True,
+    )
+
+    print("✔ Existing Celery processes cleared\n")
+
+    print("Starting services...\n")
+
+    subprocess.Popen(
+        ["celery", "-A", "paystream", "worker", "-l", "info"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    print("✔ Celery worker started")
+
+    subprocess.Popen(
+        ["celery", "-A", "paystream", "beat", "-l", "info"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    print("✔ Celery beat started\n")

djangoplay_cli-1.0.0/dplay/utils/subprocess_utils.py

@@ -0,0 +1,5 @@
+"""
+Subprocess helper utilities.
+
+Reserved for future releases.
+"""

djangoplay_cli-1.0.0/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "djangoplay-cli"
+version = "1.0.0"
+description = "CLI tools for DjangoPlay developers. 'djangoplay-cli' provides a lightweight command-line interface for developers working on the 'DjangoPlay ecosystem'."
+requires-python = ">=3.11"
+
+dependencies = [
+    "typer>=0.9",
+    "rich>=13",
+    "pyyaml>=6.0"
+]
+
+[project.scripts]
+dplay = "dplay.cli:main"

djangoplay_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+