quickscale-cli 0.75.0__tar.gz → 0.76.0__tar.gz

quickscale_cli-0.76.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: quickscale-cli
+Version: 0.76.0
+Summary: Command-line interface for QuickScale Django project generator
+License-Expression: Apache-2.0
+Keywords: django,cli,project-generator,saas
+Author: Experto AI
+Author-email: victor@experto.ai
+Requires-Python: >=3.14,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 6.0
+Requires-Dist: click (>=8.3.1,<9.0.0)
+Requires-Dist: quickscale-core (>=0.76.0,<0.77.0)
+Project-URL: Documentation, https://github.com/Experto-AI/quickscale/tree/main/docs
+Project-URL: Homepage, https://github.com/Experto-AI/quickscale
+Project-URL: Repository, https://github.com/Experto-AI/quickscale
+Description-Content-Type: text/markdown
+
+# quickscale-cli
+
+Command-line interface package for QuickScale.
+
+This package exposes the `quickscale` command used to plan, apply, inspect, and operate generated projects.
+
+## Command groups
+
+- Project lifecycle: `plan`, `apply`, `status`, `remove`
+- Local development: `up`, `down`, `ps`, `logs`, `shell`, `manage`
+- Deployment: `deploy`
+- Module workflows: `update`, `push`
+
+## Relationship to other packages
+
+- `quickscale-cli` is the command surface
+- `quickscale-core` contains the underlying scaffolding and template logic
+- `quickscale` installs both together for convenience
+
+## Install
+
+Usually installed via the meta-package:
+
+```bash
+pip install quickscale
+```
+
+Standalone package installs can use this package's published metadata and dependency constraints.
+
+## Documentation
+
+- Repository overview: [QuickScale README](https://github.com/Experto-AI/quickscale/blob/main/README.md)
+- Start guide: [START_HERE.md](https://github.com/Experto-AI/quickscale/blob/main/START_HERE.md)
+- Technical decisions: [docs/technical/decisions.md](https://github.com/Experto-AI/quickscale/blob/main/docs/technical/decisions.md)
+- CLI source entrypoint: [src/quickscale_cli/main.py](https://github.com/Experto-AI/quickscale/blob/main/quickscale_cli/src/quickscale_cli/main.py)
+
+This README is package-local context only. Root documentation remains authoritative for repo-wide policy and scope.
+

quickscale_cli-0.76.0/README.md

@@ -0,0 +1,37 @@
+# quickscale-cli
+
+Command-line interface package for QuickScale.
+
+This package exposes the `quickscale` command used to plan, apply, inspect, and operate generated projects.
+
+## Command groups
+
+- Project lifecycle: `plan`, `apply`, `status`, `remove`
+- Local development: `up`, `down`, `ps`, `logs`, `shell`, `manage`
+- Deployment: `deploy`
+- Module workflows: `update`, `push`
+
+## Relationship to other packages
+
+- `quickscale-cli` is the command surface
+- `quickscale-core` contains the underlying scaffolding and template logic
+- `quickscale` installs both together for convenience
+
+## Install
+
+Usually installed via the meta-package:
+
+```bash
+pip install quickscale
+```
+
+Standalone package installs can use this package's published metadata and dependency constraints.
+
+## Documentation
+
+- Repository overview: [QuickScale README](https://github.com/Experto-AI/quickscale/blob/main/README.md)
+- Start guide: [START_HERE.md](https://github.com/Experto-AI/quickscale/blob/main/START_HERE.md)
+- Technical decisions: [docs/technical/decisions.md](https://github.com/Experto-AI/quickscale/blob/main/docs/technical/decisions.md)
+- CLI source entrypoint: [src/quickscale_cli/main.py](https://github.com/Experto-AI/quickscale/blob/main/quickscale_cli/src/quickscale_cli/main.py)
+
+This README is package-local context only. Root documentation remains authoritative for repo-wide policy and scope.

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/pyproject.toml

@@ -1,39 +1,42 @@
-[tool.poetry]
+[project]
 name = "quickscale-cli"
-version = "0.75.0"
+version = "0.76.0"
 description = "Command-line interface for QuickScale Django project generator"
-authors = ["Experto AI <victor@experto.ai>"]
+requires-python = ">=3.14,<4.0"
+readme = "README.md"
 license = "Apache-2.0"
+authors = [{name = "Experto AI", email = "victor@experto.ai"}]
 keywords = ["django", "cli", "project-generator", "saas"]
-homepage = "https://github.com/Experto-AI/quickscale"
-repository = "https://github.com/Experto-AI/quickscale"
-documentation = "https://github.com/Experto-AI/quickscale/tree/main/docs"
-readme = "README.md"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Framework :: Django",
     "Framework :: Django :: 6.0",
 ]
+dynamic = ["dependencies"]
+
+[project.urls]
+Homepage = "https://github.com/Experto-AI/quickscale"
+Repository = "https://github.com/Experto-AI/quickscale"
+Documentation = "https://github.com/Experto-AI/quickscale/tree/main/docs"
+
+[project.scripts]
+quickscale = "quickscale_cli.main:cli"
+
+[tool.poetry]
 packages = [{include = "quickscale_cli", from = "src"}]
 
 [tool.poetry.dependencies]
-python = "^3.12"
+python = "^3.14"
 click = "^8.3.1"
-quickscale-core = "^0.75.0"
+quickscale-core = "^0.76.0"
 
 [tool.poetry.group.dev.dependencies]
 # Dev dependencies centralized in root pyproject.toml
 # Use: poetry install from repository root
 
-[tool.poetry.scripts]
-quickscale = "quickscale_cli.main:cli"
-
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -46,10 +49,6 @@ python_functions = ["test_*"]
 addopts = [
     "--strict-markers",
     "--strict-config",
-    "--cov=quickscale_cli",
-    "--cov-report=term-missing",
-    "--cov-report=html",
-    "--cov-fail-under=90",
     "-m", "not e2e",  # Skip E2E tests by default (run with: pytest -m e2e)
 ]
 markers = [

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/src/quickscale_cli/_version.py

@@ -1,2 +1,2 @@
 # Auto-generated by scripts/version_tool.sh
-__version__ = "0.75.0"
+__version__ = "0.76.0"

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/src/quickscale_cli/commands/apply_command.py

@@ -105,24 +105,6 @@ def _generate_project(config: QuickScaleConfig, output_path: Path) -> bool:
             f"(package: {config.project.package})..."
         )
 
-        # Validate theme availability
-        if config.project.theme == "showcase_htmx":
-            click.secho(
-                f"❌ Error: Theme '{config.project.theme}' is not yet implemented",
-                fg="red",
-                err=True,
-            )
-            click.echo(
-                "\n💡 The 'showcase_htmx' theme is planned for a future release:",
-                err=True,
-            )
-            click.echo("   - showcase_htmx: Coming in v0.78.0", err=True)
-            click.echo(
-                "   - Use 'showcase_react' (default) or 'showcase_html' instead",
-                err=True,
-            )
-            return False
-
         generator = ProjectGenerator(theme=config.project.theme)
         # mypy can resolve an older installed quickscale-core signature here.
         generate_project = cast(Any, generator.generate)
@@ -281,6 +263,7 @@ def _start_docker(
             cmd,
             project_path,
             "Starting Docker services",
+            capture=False,
         )
         return success
 
@@ -575,6 +558,45 @@ def _init_git_with_config(output_path: Path) -> None:
         click.secho("⚠️  Initial commit failed, continuing...", fg="yellow")
 
 
+def _commit_pending_config_changes(output_path: Path) -> None:
+    """Commit pending QuickScale config changes before module embedding
+
+    Stages and commits quickscale.yml and .quickscale/ directory changes so
+    git subtree operations have a clean working directory.  Called before
+    embedding modules in existing projects.
+
+    Args:
+        output_path: Path to the project directory
+
+    """
+    if is_working_directory_clean(output_path):
+        return
+
+    # Stage only QuickScale-managed config files
+    subprocess.run(
+        ["git", "add", "quickscale.yml", ".quickscale/"],
+        cwd=output_path,
+        capture_output=True,
+        check=False,
+    )
+
+    # Check if anything was staged
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--name-only"],
+        cwd=output_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    if result.stdout.strip():
+        _run_command(
+            ["git", "commit", "-m", "Update QuickScale configuration"],
+            output_path,
+            "Committing pending QuickScale configuration changes",
+        )
+
+
 def _embed_modules_step(
     output_path: Path,
     modules_to_embed: list[str],
@@ -824,6 +846,13 @@ def _execute_apply_steps(
         if ctx.existing_state
         else list(ctx.qs_config.modules.keys())
     )
+
+    # For existing projects, commit any pending QuickScale config changes
+    # (e.g. quickscale.yml updated by `quickscale plan`) before embedding
+    # modules, so git subtree has a clean working directory to operate on.
+    if ctx.existing_state is not None and modules_to_embed:
+        _commit_pending_config_changes(ctx.output_path)
+
     embed_result = _embed_modules_step(
         ctx.output_path, modules_to_embed, no_modules, ctx.existing_state
     )
@@ -882,16 +911,36 @@ def _execute_apply_steps(
             ctx.output_path, ctx.qs_config.docker.build, verbose_docker
         )
         if not docker_started:
-            click.secho("⚠️  Docker start failed, continuing...", fg="yellow")
+            _save_project_state(
+                ctx.output_path,
+                ctx.qs_config,
+                ctx.existing_state,
+                embedded_modules,
+                ctx.delta,
+            )
+            _print_apply_failure_summary(
+                failed_step="docker startup",
+                reason="Docker auto-start failed. Run 'quickscale logs' to inspect the failing service.",
+            )
+            raise click.Abort()
 
     # For Docker auto-start projects, run migrations in the backend container
     # so database connectivity uses the internal Docker network.
     if should_auto_start_docker:
         if docker_started:
             if not _run_migrations_in_docker(ctx.output_path):
-                click.secho("⚠️  Migrations failed, continuing...", fg="yellow")
-        elif not _run_migrations(ctx.output_path):
-            click.secho("⚠️  Migrations failed, continuing...", fg="yellow")
+                _save_project_state(
+                    ctx.output_path,
+                    ctx.qs_config,
+                    ctx.existing_state,
+                    embedded_modules,
+                    ctx.delta,
+                )
+                _print_apply_failure_summary(
+                    failed_step="database migrations",
+                    reason="Migrations failed inside Docker backend container. Run 'quickscale logs backend' for details.",
+                )
+                raise click.Abort()
 
     # Save state
     _save_project_state(

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/src/quickscale_cli/commands/deployment_commands.py

@@ -457,7 +457,12 @@ def _display_summary(
     else:
         click.echo("   3. Get URL: railway status")
     click.echo(
-        f"   4. Create superuser: railway run --service {app_service} "
+        "   4. Create superuser automatically: set DJANGO_SUPERUSER_USERNAME, "
+        "DJANGO_SUPERUSER_EMAIL and DJANGO_SUPERUSER_PASSWORD variables in Railway "
+        "dashboard — start.sh will create it on next deploy"
+    )
+    click.echo(
+        f"      Or manually: railway run --service {app_service} "
         f"python manage.py createsuperuser"
     )
     click.echo("   5. Configure custom domain (optional): railway domain")

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/src/quickscale_cli/commands/development_commands.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 import click
 
+from quickscale_cli.schema.config_schema import QuickScaleConfig
 from quickscale_cli.utils.docker_utils import (
     get_docker_compose_command,
     get_port_from_env,
@@ -140,6 +141,100 @@ def _handle_up_error(error: subprocess.CalledProcessError) -> None:
         )
 
 
+def _run_migrations_after_up() -> None:
+    """Run Django migrations in backend container after services start"""
+    click.echo("⏳ Applying database migrations...")
+    container_name = get_backend_container_name()
+    _run_docker_exec_command(
+        container_name,
+        ["python", "manage.py", "migrate"],
+        capture=True,
+    )
+    click.secho("✅ Database migrations applied", fg="green")
+
+
+def _superuser_exists_in_backend(container_name: str) -> bool | None:
+    """Check whether a Django superuser already exists
+
+    Returns:
+        True when at least one superuser exists
+        False when no superuser exists
+        None when status cannot be verified reliably
+    """
+    check_cmd = [
+        "docker",
+        "exec",
+        container_name,
+        "python",
+        "manage.py",
+        "shell",
+        "-c",
+        (
+            "from django.contrib.auth import get_user_model; import sys; "
+            "sys.exit(0 if get_user_model().objects.filter(is_superuser=True).exists() else 1)"
+        ),
+    ]
+    result = subprocess.run(check_cmd, capture_output=True, text=True)
+    if result.returncode == 0:
+        return True
+
+    stdout_output = (result.stdout or "").strip()
+    stderr_output = (result.stderr or "").strip()
+
+    if result.returncode == 1 and not stdout_output and not stderr_output:
+        return False
+
+    return None
+
+
+def _handle_superuser_after_up(config: QuickScaleConfig | None) -> None:
+    """Create superuser if configured and one does not already exist"""
+    if config is None or config.docker is None:
+        return
+
+    if not getattr(config.docker, "create_superuser", False):
+        return
+
+    container_name = get_backend_container_name()
+    superuser_exists = _superuser_exists_in_backend(container_name)
+    interactive_session = is_interactive()
+
+    if superuser_exists is True:
+        click.echo("ℹ️  Superuser already exists. Skipping createsuperuser step.")
+        return
+
+    if superuser_exists is None:
+        click.secho("⚠️  Could not verify superuser status.", fg="yellow")
+        if not interactive_session:
+            click.echo("   Run: quickscale manage createsuperuser")
+            return
+        click.echo("   Proceeding with interactive superuser creation.")
+    elif not interactive_session:
+        click.secho(
+            "⚠️  Superuser creation is enabled but requires interactive input.",
+            fg="yellow",
+        )
+        click.echo("   Run: quickscale manage createsuperuser")
+        return
+
+    click.echo("👤 Creating Django superuser...")
+    _run_docker_exec_command(
+        container_name,
+        ["python", "manage.py", "createsuperuser"],
+        capture=False,
+    )
+
+
+def _command_contains(error: subprocess.CalledProcessError, *tokens: str) -> bool:
+    """Check whether error command contains all tokens"""
+    cmd = error.cmd
+    if isinstance(cmd, list):
+        cmd_text = " ".join(str(part) for part in cmd)
+    else:
+        cmd_text = str(cmd)
+    return all(token in cmd_text for token in tokens)
+
+
 @click.command()
 @click.option("--build", is_flag=True, help="Rebuild containers before starting")
 @click.option("--no-cache", is_flag=True, help="Build without using cache")
@@ -180,8 +275,33 @@ def up(build: bool, no_cache: bool) -> None:
         if should_build:
             _update_last_build_timestamp()
 
+        _run_migrations_after_up()
+        _handle_superuser_after_up(config)
+
     except subprocess.CalledProcessError as e:
-        _handle_up_error(e)
+        if _command_contains(e, "manage.py", "migrate"):
+            click.secho(
+                "❌ Error: Services started but database migration failed",
+                fg="red",
+                err=True,
+            )
+            if e.stderr:
+                click.echo(f"\nError output:\n{e.stderr}", err=True)
+            click.echo(
+                "💡 Tip: Run 'quickscale manage migrate' and inspect logs with 'quickscale logs backend'",
+                err=True,
+            )
+        elif _command_contains(e, "manage.py", "createsuperuser"):
+            click.secho(
+                "❌ Error: Services started but superuser creation failed",
+                fg="red",
+                err=True,
+            )
+            click.echo(
+                "💡 Tip: Run 'quickscale manage createsuperuser' manually", err=True
+            )
+        else:
+            _handle_up_error(e)
         sys.exit(1)
     except KeyboardInterrupt:
         click.echo("\n⚠️  Interrupted by user")
@@ -428,7 +548,7 @@ def _dependencies_changed_since_last_build() -> bool:
         )
         return changed
 
-    except (json.JSONDecodeError, KeyError, OSError):
+    except json.JSONDecodeError, KeyError, OSError:
         # If we can't read state, don't warn (fail safe)
         return False
 

{quickscale_cli-0.75.0 → quickscale_cli-0.76.0}/src/quickscale_cli/commands/module_commands.py

@@ -195,7 +195,7 @@ def _perform_module_embed(
         applier(project_path, config)
 
     # Install dependencies for modules that need it
-    if module in ["auth", "blog", "listings", "crm", "forms"]:
+    if module in ["auth", "blog", "listings", "crm", "forms", "storage"]:
         if not _install_module_dependencies(project_path, module):
             return False
 
@@ -440,7 +440,7 @@ def _validate_update_environment() -> None:
 
 def _update_single_module(
     name: str, info: Any, default_remote: str, no_preview: bool
-) -> None:
+) -> bool:
     """Update a single module via git subtree pull."""
     click.echo(f"\n📥 Updating {name} module...")
 
@@ -455,15 +455,62 @@ def _update_single_module(
         # Update version in config
         update_module_version(name, "v0.62.0")  # Placeholder version
 
+        _commit_module_update(name, info.prefix)
+
         click.secho(f"✅ Updated {name} successfully", fg="green")
 
         if output and not no_preview:
             click.echo("\n📋 Changes summary:")
             click.echo(output[:500])  # Show first 500 chars
 
+        return True
+
     except GitError as e:
         click.secho(f"❌ Failed to update {name}: {e}", fg="red", err=True)
         click.echo(f"💡 Tip: Check for conflicts in modules/{name}/", err=True)
+        return False
+
+
+def _commit_module_update(module_name: str, module_prefix: str) -> None:
+    """Create a commit for a successfully updated module."""
+    tracked_paths = [module_prefix]
+    config_path = Path(".quickscale") / "config.yml"
+    if config_path.exists():
+        tracked_paths.append(str(config_path))
+
+    try:
+        subprocess.run(
+            ["git", "add", *tracked_paths],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise GitError(f"Failed to stage {module_name} update commit: {e.stderr}")
+
+    cached_diff = subprocess.run(
+        ["git", "diff", "--cached", "--quiet"],
+        capture_output=True,
+        text=True,
+    )
+
+    if cached_diff.returncode == 0:
+        click.echo(f"ℹ️  No staged changes detected for {module_name}; skipping commit")
+        return
+
+    if cached_diff.returncode != 1:
+        raise GitError("Failed to inspect staged changes before module update commit")
+
+    commit_message = f"chore(modules): update {module_name} module"
+    try:
+        subprocess.run(
+            ["git", "commit", "-m", commit_message],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise GitError(f"Failed to commit {module_name} update: {e.stderr}")
 
 
 @click.command()
@@ -487,6 +534,7 @@ def update(no_preview: bool) -> None:
       - Updates ONLY modules you've explicitly installed
       - Shows a diff preview before updating (unless --no-preview)
       - Updates the installed version in config after successful update
+            - Commits each successful module update before continuing
     """
     try:
         _validate_update_environment()
@@ -514,15 +562,34 @@ def update(no_preview: bool) -> None:
             click.echo("❌ Update cancelled")
             return
 
+        failed_modules: list[str] = []
+
         # Update each module
         for name, info in config.modules.items():
-            _update_single_module(name, info, config.default_remote, no_preview)
+            if not _update_single_module(name, info, config.default_remote, no_preview):
+                failed_modules.append(name)
+                break
+
+        if failed_modules:
+            click.secho(
+                "\n❌ Module update stopped due to failure",
+                fg="red",
+                bold=True,
+                err=True,
+            )
+            click.echo(
+                f"Failed module(s): {', '.join(failed_modules)}",
+                err=True,
+            )
+            raise click.Abort()
 
         click.secho("\n🎉 Module update complete!", fg="green", bold=True)
 
     except GitError as e:
         click.secho(f"❌ Git error: {e}", fg="red", err=True)
         raise click.Abort()
+    except click.Abort:
+        raise
     except Exception as e:
         click.secho(f"❌ Unexpected error: {e}", fg="red", err=True)
         raise click.Abort()