krickstart 1.2.0__py3-none-any.whl

devspeed/__init__.py

@@ -0,0 +1,15 @@
+"""Legacy compatibility package alias for Slipway."""
+
+from __future__ import annotations
+
+import warnings
+
+from slipway import PLUGIN_API_VERSION, StackPlugin, __version__
+
+warnings.warn(
+    "'devspeed' has been renamed to 'slipway'. Please update imports to 'slipway'.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+__all__ = ["PLUGIN_API_VERSION", "StackPlugin", "__version__"]

devspeed/cli.py

@@ -0,0 +1,21 @@
+"""Backward-compatibility aliases for devspeed.cli."""
+
+from __future__ import annotations
+
+from slipway.cli import (
+    GENERATED_COMPOSE,
+    GENERATED_ENV,
+    GENERATED_ENV_EXAMPLE,
+    build_parser,
+    deprecated_alias_main,
+)
+from slipway.cli import deprecated_alias_main as main
+
+__all__ = [
+    "GENERATED_COMPOSE",
+    "GENERATED_ENV",
+    "GENERATED_ENV_EXAMPLE",
+    "build_parser",
+    "deprecated_alias_main",
+    "main",
+]

devspeed/config.py

@@ -0,0 +1,29 @@
+"""Backward-compatibility aliases for devspeed.config."""
+
+from __future__ import annotations
+
+from slipway.config import (
+    CONFIG_FILENAME,
+    LEGACY_CONFIG_FILENAME,
+    DevspeedConfig,
+    LifecycleConfig,
+    ServiceConfig,
+    SlipwayConfig,
+    config_path,
+    load_config,
+    save_config,
+    validate_config,
+)
+
+__all__ = [
+    "CONFIG_FILENAME",
+    "LEGACY_CONFIG_FILENAME",
+    "DevspeedConfig",
+    "LifecycleConfig",
+    "ServiceConfig",
+    "SlipwayConfig",
+    "config_path",
+    "load_config",
+    "save_config",
+    "validate_config",
+]

devspeed/core/__init__.py

@@ -0,0 +1,29 @@
+"""Core generation services for DevSpeed (legacy alias)."""
+
+from slipway.core.compose_generator import (
+    DEFAULT_COMPOSE_FILENAME,
+    DEFAULT_ENV_FILENAME,
+    ComposeGenerationError,
+    ComposeGenerator,
+    ConfigValidationError,
+    GeneratedArtifacts,
+    GeneratorSettings,
+    OutputFileExistsError,
+    PluginResolutionError,
+    PortConflictError,
+    WriteResult,
+)
+
+__all__ = [
+    "DEFAULT_COMPOSE_FILENAME",
+    "DEFAULT_ENV_FILENAME",
+    "ComposeGenerationError",
+    "ComposeGenerator",
+    "ConfigValidationError",
+    "GeneratedArtifacts",
+    "GeneratorSettings",
+    "OutputFileExistsError",
+    "PluginResolutionError",
+    "PortConflictError",
+    "WriteResult",
+]

devspeed/core/compose_generator.py

@@ -0,0 +1,3 @@
+"""Backward-compatibility aliases for devspeed.core.compose_generator."""
+
+from slipway.core.compose_generator import *  # noqa: F403

devspeed/errors.py

@@ -0,0 +1,29 @@
+"""Backward-compatibility aliases for devspeed.errors."""
+
+from __future__ import annotations
+
+from slipway.errors import (
+    CommandFailedError,
+    ComposeNotFoundError,
+    ConfigNotFoundError,
+    ConfigValidationError,
+    DevspeedError,
+    DockerNotFoundError,
+    DockerNotRunningError,
+    PortConflictError,
+    SlipwayError,
+    UnknownStackError,
+)
+
+__all__ = [
+    "CommandFailedError",
+    "ComposeNotFoundError",
+    "ConfigNotFoundError",
+    "ConfigValidationError",
+    "DevspeedError",
+    "DockerNotFoundError",
+    "DockerNotRunningError",
+    "PortConflictError",
+    "SlipwayError",
+    "UnknownStackError",
+]

devspeed/plugin.py

@@ -0,0 +1,25 @@
+"""Backward-compatibility aliases for devspeed.plugin."""
+
+from __future__ import annotations
+
+from slipway.plugin import (
+    ENTRY_POINT_GROUP,
+    PLUGIN_API_VERSION,
+    PluginError,
+    PluginRegistry,
+    StackPlugin,
+    builtin_registry,
+    discover_pypi_stack_packages,
+    pypi_package_metadata,
+)
+
+__all__ = [
+    "ENTRY_POINT_GROUP",
+    "PLUGIN_API_VERSION",
+    "PluginError",
+    "PluginRegistry",
+    "StackPlugin",
+    "builtin_registry",
+    "discover_pypi_stack_packages",
+    "pypi_package_metadata",
+]

devspeed/plugins/__init__.py

@@ -0,0 +1,21 @@
+"""Public plugin API for DevSpeed."""
+
+from devspeed.plugins.base import PLUGIN_API_VERSION, PluginError, StackPlugin
+from devspeed.plugins.registry import (
+    ENTRY_POINT_GROUP,
+    PluginRegistry,
+    builtin_registry,
+    discover_pypi_stack_packages,
+    pypi_package_metadata,
+)
+
+__all__ = [
+    "ENTRY_POINT_GROUP",
+    "PLUGIN_API_VERSION",
+    "PluginError",
+    "PluginRegistry",
+    "StackPlugin",
+    "builtin_registry",
+    "discover_pypi_stack_packages",
+    "pypi_package_metadata",
+]

devspeed/plugins/base.py

@@ -0,0 +1,7 @@
+"""Backward-compatibility aliases for devspeed.plugins.base."""
+
+from __future__ import annotations
+
+from slipway.plugins.base import PLUGIN_API_VERSION, PluginError, StackPlugin
+
+__all__ = ["PLUGIN_API_VERSION", "PluginError", "StackPlugin"]

devspeed/plugins/registry.py

@@ -0,0 +1,29 @@
+"""Backward-compatibility aliases for devspeed.plugins.registry."""
+
+from __future__ import annotations
+
+from slipway.plugins.registry import (
+    ENTRY_POINT_GROUP,
+    LEGACY_ENTRY_POINT_GROUP,
+    PLUGIN_API_VERSION,
+    PluginError,
+    PluginFactory,
+    PluginRegistry,
+    StackPlugin,
+    builtin_registry,
+    discover_pypi_stack_packages,
+    pypi_package_metadata,
+)
+
+__all__ = [
+    "ENTRY_POINT_GROUP",
+    "LEGACY_ENTRY_POINT_GROUP",
+    "PLUGIN_API_VERSION",
+    "PluginError",
+    "PluginFactory",
+    "PluginRegistry",
+    "StackPlugin",
+    "builtin_registry",
+    "discover_pypi_stack_packages",
+    "pypi_package_metadata",
+]

devspeed/stacks/__init__.py

@@ -0,0 +1,21 @@
+"""Backward-compatibility aliases for devspeed.stacks."""
+
+from __future__ import annotations
+
+from slipway.stacks import (
+    STACKS,
+    PluginRegistry,
+    StackPlugin,
+    get_registry,
+    get_stack,
+    list_stacks,
+)
+
+__all__ = [
+    "STACKS",
+    "PluginRegistry",
+    "StackPlugin",
+    "get_registry",
+    "get_stack",
+    "list_stacks",
+]

devspeed/stacks/common.py

@@ -0,0 +1,66 @@
+"""Shared rendering helpers for stack templates."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from typing import Any
+
+
+def postgres_service_yaml(
+    postgres: Mapping[str, Any],
+    project: str,
+    *,
+    database_url: bool = False,
+) -> str:
+    """Render the common Postgres service and named volume block."""
+    database_line = ""
+    if database_url:
+        database_line = (
+            f"      - DATABASE_URL=postgres://{postgres['user']}:{postgres['password']}"
+            f"@postgres:5432/{postgres['db']}\n"
+        )
+    return f"""\
+  postgres:
+    image: postgres:16-alpine
+    ports:
+      - \"127.0.0.1:{postgres["port"]}:5432\"
+
+    environment:
+      - POSTGRES_DB={postgres["db"]}
+      - POSTGRES_USER={postgres["user"]}
+      - POSTGRES_PASSWORD={postgres["password"]}
+{database_line}    volumes:
+      - {project}_pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: [\"CMD-SHELL\", \"pg_isready -U {postgres["user"]}\"]
+      interval: 3s
+      timeout: 3s
+      retries: 10
+
+  
+volumes:
+  {project}_pgdata:
+"""
+
+
+def env_example(env_text: str) -> str:
+    """Mask common local credentials while preserving useful connection examples."""
+    masked = re.sub(r"(://[^:]+:)[^@]+@", r"\1<password>@", env_text)
+    return re.sub(r"(?m)^(POSTGRES_PASSWORD=).*$", r"\1<password>", masked)
+
+
+def lifecycle_command(
+    config: Mapping[str, Any],
+    default_install: str,
+    default_dev: str,
+) -> str:
+    """Build the app command, allowing config to override lifecycle steps."""
+    lifecycle = config.get("lifecycle", {})
+    if not isinstance(lifecycle, Mapping):
+        lifecycle = {}
+    install = lifecycle.get("install", default_install)
+    dev = lifecycle.get("dev", default_dev)
+    if not isinstance(install, str) or not isinstance(dev, str):
+        raise TypeError("lifecycle.install and lifecycle.dev must be strings")
+    return f'sh -c "{install} && {dev}"'

devspeed/stacks/django_postgres.py

@@ -0,0 +1,168 @@
+"""Django and Postgres stack plugin."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from devspeed.plugins.base import StackPlugin
+
+from .common import lifecycle_command, postgres_service_yaml
+
+
+class DjangoPostgresPlugin(StackPlugin):
+    """Provide a hot-reloading Django application with Postgres."""
+
+    @property
+    def name(self) -> str:
+        """Return the stable configuration identifier."""
+        return "django-postgres"
+
+    @property
+    def description(self) -> str:
+        """Return the stack description shown by the CLI."""
+        return "Django web app + Postgres"
+
+    def default_config(self, project_name: str) -> dict[str, Any]:
+        """Return defaults for a Django project."""
+        return {
+            "project": project_name,
+            "stack": self.name,
+            "lifecycle": {
+                "install": "pip install --no-cache-dir -r requirements.txt",
+                "dev": "python manage.py migrate --noinput && python manage.py runserver 0.0.0.0:8000",
+            },
+            "services": {
+                "app": {"port": 8000, "python_version": "3.12"},
+                "postgres": {
+                    "port": 5432,
+                    "db": project_name.replace("-", "_"),
+                    "user": "devspeed",
+                    "password": "devspeed",
+                },
+            },
+        }
+
+    def starter_files(self, config: Mapping[str, Any]) -> dict[str, str]:
+        """Return a minimal Django project for a new project."""
+        return {
+            "requirements.txt": "Django>=5.1,<6\npsycopg[binary]>=3.2,<4\n",
+            "manage.py": """import os
+import sys
+
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+    from django.core.management import execute_from_command_line
+    execute_from_command_line(sys.argv)
+""",
+            "config/__init__.py": "",
+            "config/settings.py": """import os
+
+SECRET_KEY = "devspeed-local-only"
+DEBUG = True
+ROOT_URLCONF = "config.urls"
+ALLOWED_HOSTS = ["*"]
+INSTALLED_APPS = ["django.contrib.contenttypes"]
+MIDDLEWARE = []
+DATABASES = {"default": {
+    "ENGINE": "django.db.backends.postgresql",
+    "NAME": os.getenv("POSTGRES_DB", "devspeed"),
+    "USER": os.getenv("POSTGRES_USER", "devspeed"),
+    "PASSWORD": os.getenv("POSTGRES_PASSWORD", "devspeed"),
+    "HOST": os.getenv("POSTGRES_HOST", "postgres"),
+    "PORT": "5432",
+}}
+""",
+            "config/urls.py": """from django.http import JsonResponse
+from django.urls import path
+
+
+urlpatterns = [path("", lambda request: JsonResponse({"message": "Your DevSpeed app is running"}))]
+""",
+        }
+
+    def compose_yaml(self, config: Mapping[str, Any]) -> str:
+        """Render the Django and Postgres Compose services."""
+        services = config["services"]
+        app = services["app"]
+        postgres = services["postgres"]
+        project = config["project"]
+        app_command = lifecycle_command(
+            config,
+            "pip install --no-cache-dir -r requirements.txt",
+            f"python manage.py migrate --noinput && python manage.py runserver 0.0.0.0:{app['port']}",
+        )
+        postgres_yaml = postgres_service_yaml(postgres, project, database_url=False)
+
+        return f"""\
+name: {project}
+
+services:
+  app:
+    image: python:{app["python_version"]}-slim
+    working_dir: /app
+    volumes:
+      - ./:/app
+    command: {app_command}
+    ports:
+      - "{app["port"]}:{app["port"]}"
+    environment:
+      - DATABASE_URL=postgres://{postgres["user"]}:{postgres["password"]}@postgres:5432/{postgres["db"]}
+      - POSTGRES_DB={postgres["db"]}
+      - POSTGRES_USER={postgres["user"]}
+      - POSTGRES_PASSWORD={postgres["password"]}
+      - POSTGRES_HOST=postgres
+    depends_on:
+      postgres:
+        condition: service_healthy
+
+{postgres_yaml}
+"""
+
+    def env_file(self, config: Mapping[str, Any]) -> str:
+        """Render the host Postgres connection variable."""
+        postgres = config["services"]["postgres"]
+        return (
+            f"DATABASE_URL=postgres://{postgres['user']}:{postgres['password']}"
+            f"@localhost:{postgres['port']}/{postgres['db']}\n"
+        )
+
+    def post_up_hints(self, config: Mapping[str, Any]) -> list[str]:
+        """Return startup notes for the generated Django environment."""
+        app_port = config["services"]["app"]["port"]
+        return [
+            "App container installs requirements.txt and runs Django's development server.",
+            f"Django should be reachable at http://localhost:{app_port} once dependencies finish installing.",
+            "Make sure manage.py and requirements.txt are present at the project root.",
+        ]
+
+
+plugin = DjangoPostgresPlugin()
+NAME = plugin.name
+DESCRIPTION = plugin.description
+
+
+def default_config(project_name: str) -> dict[str, Any]:
+    """Backward-compatible wrapper for the plugin method."""
+    return plugin.default_config(project_name)
+
+
+def starter_files(config: Mapping[str, Any]) -> dict[str, str]:
+    """Backward-compatible wrapper for the plugin method."""
+    return plugin.starter_files(config)
+
+
+def compose_yaml(config: Mapping[str, Any]) -> str:
+    """Backward-compatible wrapper for the plugin method."""
+    return plugin.compose_yaml(config)
+
+
+def env_file(config: Mapping[str, Any]) -> str:
+    """Backward-compatible wrapper for the plugin method."""
+    return plugin.env_file(config)
+
+
+def post_up_hints(config: Mapping[str, Any]) -> list[str]:
+    """Backward-compatible wrapper for the plugin method."""
+    return plugin.post_up_hints(config)

devspeed/stacks/express_mongodb.py

@@ -0,0 +1,128 @@
+"""Express and MongoDB stack plugin."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from devspeed.plugins.base import StackPlugin
+
+from .common import lifecycle_command
+
+
+class ExpressMongodbPlugin(StackPlugin):
+    """Provide a Node.js Express application with MongoDB."""
+
+    @property
+    def name(self) -> str:
+        return "express-mongodb"
+
+    @property
+    def description(self) -> str:
+        return "Node.js Express API + MongoDB"
+
+    def default_config(self, project_name: str) -> dict[str, Any]:
+        return {
+            "project": project_name,
+            "stack": self.name,
+            "lifecycle": {
+                "install": "npm install",
+                "dev": "npm run dev",
+            },
+            "services": {
+                "app": {"port": 3000, "node_version": "20"},
+                "mongodb": {
+                    "port": 27017,
+                    "user": "devspeed",
+                    "password": "devspeed",
+                },
+            },
+        }
+
+    def starter_files(self, config: Mapping[str, Any]) -> dict[str, str]:
+        return {
+            "package.json": '{\n  "name": "devspeed-express",\n  "version": "1.0.0",\n  "scripts": { "dev": "node app.js" },\n  "dependencies": { "express": "^4.19.0", "mongoose": "^8.0.0" }\n}',
+            "app.js": 'const express = require("express");\nconst mongoose = require("mongoose");\n\nconst app = express();\nconst port = 3000;\n\nmongoose.connect(process.env.MONGODB_URI).then(() => console.log("Connected to MongoDB"));\n\napp.get("/", (req, res) => res.json({ message: "Your DevSpeed app is running" }));\n\napp.listen(port, () => console.log(`App listening on port ${port}`));',
+        }
+
+    def compose_yaml(self, config: Mapping[str, Any]) -> str:
+        services = config["services"]
+        app = services["app"]
+        mongo = services["mongodb"]
+        project = config["project"]
+        command = lifecycle_command(
+            config,
+            "npm install",
+            "npm run dev",
+        )
+        return f"""\
+name: {project}
+
+services:
+  app:
+    image: node:{app["node_version"]}-slim
+    working_dir: /app
+    volumes:
+      - ./:/app
+    command: {command}
+    ports:
+      - "{app["port"]}:{app["port"]}"
+    environment:
+      - MONGODB_URI=mongodb://{mongo["user"]}:{mongo["password"]}@mongodb:27017/devspeed_db?authSource=admin
+    depends_on:
+      mongodb:
+        condition: service_healthy
+
+  mongodb:
+    image: mongo:6-alpine
+    ports:
+      - "{mongo["port"]}:27017"
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME={mongo["user"]}
+      - MONGO_INITDB_ROOT_PASSWORD={mongo["password"]}
+    healthcheck:
+      test: ["CMD", "mongo", "--eval", "db.adminCommand('ping')"]
+      interval: 3s
+      timeout: 3s
+      retries: 10
+
+volumes:
+  {project}_mongodata:
+"""
+
+    def env_file(self, config: Mapping[str, Any]) -> str:
+        mongo = config["services"]["mongodb"]
+        return f"MONGODB_URI=mongodb://{mongo['user']}:{mongo['password']}@localhost:{mongo['port']}/devspeed_db?authSource=admin\n"
+
+    def post_up_hints(self, config: Mapping[str, Any]) -> list[str]:
+        port = config["services"]["app"]["port"]
+        return [
+            "App container runs npm install and npm run dev.",
+            f"API should be reachable at http://localhost:{port} once dependencies finish installing.",
+            "Make sure app.js is configured to use MONGODB_URI.",
+        ]
+
+
+plugin = ExpressMongodbPlugin()
+NAME = plugin.name
+DESCRIPTION = plugin.description
+
+
+def default_config(project_name: str) -> dict[str, Any]:
+    return plugin.default_config(project_name)
+
+
+def starter_files(config: Mapping[str, Any]) -> dict[str, str]:
+    return plugin.starter_files(config)
+
+
+def compose_yaml(config: Mapping[str, Any]) -> str:
+    return plugin.compose_yaml(config)
+
+
+def env_file(config: Mapping[str, Any]) -> str:
+    return plugin.env_file(config)
+
+
+def post_up_hints(config: Mapping[str, Any]) -> list[str]:
+    return plugin.post_up_hints(config)