shipit-cli 0.10.1__tar.gz → 0.11.1__tar.gz

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.10.1
+Version: 0.11.1
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.10.1"
+version = "0.11.1"
 description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/cli.py

@@ -16,6 +16,7 @@ from typing import (
     Optional,
     Protocol,
     Set,
+    Tuple,
     TypedDict,
     Union,
     Literal,
@@ -33,7 +34,7 @@ from rich.rule import Rule
 from rich.syntax import Syntax
 
 from shipit.version import version as shipit_version
-from shipit.generator import generate_shipit
+from shipit.generator import generate_shipit, detect_provider
 from shipit.providers.base import CustomCommands
 from shipit.procfile import Procfile
 from dotenv import dotenv_values
@@ -88,11 +89,13 @@ class Serve:
 class Package:
     name: str
     version: Optional[str] = None
+    architecture: Optional[Literal["64-bit", "32-bit"]] = None
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
+        name = f"{self.name}({self.architecture})" if self.architecture else self.name
         if self.version is None:
-            return self.name
-        return f"{self.name}@{self.version}"
+            return name
+        return f"{name}@{self.version}"
 
 
 @dataclass
@@ -780,6 +783,25 @@ class WasmerBuilder:
             "dependencies": {
                 "latest": "php/php-32@=8.3.2102",
                 "8.3": "php/php-32@=8.3.2102",
+                "8.2": "php/php-32@=8.2.2801",
+                "8.1": "php/php-32@=8.1.3201",
+                "7.4": "php/php-32@=7.4.3301",
+            },
+            "architecture_dependencies": {
+                "64-bit": {
+                    "latest": "php/php-64@=8.3.2102",
+                    "8.3": "php/php-64@=8.3.2102",
+                    "8.2": "php/php-64@=8.2.2801",
+                    "8.1": "php/php-64@=8.1.3201",
+                    "7.4": "php/php-64@=7.4.3301",
+                },
+                "32-bit": {
+                    "latest": "php/php-32@=8.3.2102",
+                    "8.3": "php/php-32@=8.3.2102",
+                    "8.2": "php/php-32@=8.2.2801",
+                    "8.1": "php/php-32@=8.1.3201",
+                    "7.4": "php/php-32@=7.4.3301",
+                },
             },
             "scripts": {"php"},
             "aliases": {},
@@ -925,13 +947,20 @@ class WasmerBuilder:
         for dep in deps:
             if dep.name in self.mapper:
                 version = dep.version or "latest"
-                if version in self.mapper[dep.name]["dependencies"]:
+                mapped_dependencies = self.mapper[dep.name]["dependencies"]
+                if dep.architecture:
+                    architecture_dependencies = (
+                        self.mapper[dep.name]
+                        .get("architecture_dependencies", {})
+                        .get(dep.architecture, {})
+                    )
+                    if architecture_dependencies:
+                        mapped_dependencies = architecture_dependencies
+                if version in mapped_dependencies:
                     console.print(
                         f"* {dep.name}@{version} mapped to {self.mapper[dep.name]['dependencies'][version]}"
                     )
-                    package_name, version = self.mapper[dep.name]["dependencies"][
-                        version
-                    ].split("@")
+                    package_name, version = mapped_dependencies[version].split("@")
                     dependencies.add(package_name, version)
                     scripts = self.mapper[dep.name].get("scripts") or []
                     for script in scripts:
@@ -1156,6 +1185,7 @@ class Ctx:
         self.mounts: List[Mount] = []
         self.volumes: List[Volume] = []
         self.services: Dict[str, Service] = {}
+        self.getenv_variables: Set[str] = set()
 
     def add_package(self, package: Package) -> str:
         index = f"{package.name}@{package.version}" if package.version else package.name
@@ -1202,10 +1232,16 @@ class Ctx:
         return f"ref:step:{len(self.steps) - 1}"
 
     def getenv(self, name: str) -> Optional[str]:
+        self.getenv_variables.add(name)
         return self.builder.getenv(name)
 
-    def dep(self, name: str, version: Optional[str] = None) -> str:
-        package = Package(name, version)
+    def dep(
+        self,
+        name: str,
+        version: Optional[str] = None,
+        architecture: Optional[Literal["64-bit", "32-bit"]] = None,
+    ) -> str:
+        package = Package(name, version, architecture)
         return self.add_package(package)
 
     def service(
@@ -1318,6 +1354,43 @@ class Ctx:
         }
 
 
+def evaluate_shipit(path: Path, builder: Builder) -> Tuple[Ctx, Serve]:
+    shipit_file = path / "Shipit"
+    if not shipit_file.exists():
+        raise FileNotFoundError(
+            f"Shipit file not found at {shipit_file}. Run `shipit generate {path}` to create it."
+        )
+    source = shipit_file.read_text()
+    ctx = Ctx(builder)
+    glb = sl.Globals.standard()
+    mod = sl.Module()
+
+    mod.add_callable("service", ctx.service)
+    mod.add_callable("getenv", ctx.getenv)
+    mod.add_callable("dep", ctx.dep)
+    mod.add_callable("serve", ctx.serve)
+    mod.add_callable("run", ctx.run)
+    mod.add_callable("mount", ctx.mount)
+    mod.add_callable("volume", ctx.volume)
+    mod.add_callable("workdir", ctx.workdir)
+    mod.add_callable("copy", ctx.copy)
+    mod.add_callable("path", ctx.path)
+    mod.add_callable("env", ctx.env)
+    mod.add_callable("use", ctx.use)
+
+    dialect = sl.Dialect.extended()
+    dialect.enable_f_strings = True
+
+    ast = sl.parse("shipit", source, dialect=dialect)
+
+    sl.eval(mod, ast, glb)
+    if not ctx.serves:
+        raise ValueError(f"No serve definition found in {shipit_file}")
+    assert len(ctx.serves) <= 1, "Only one serve is allowed for now"
+    serve = next(iter(ctx.serves.values()))
+    return ctx, serve
+
+
 def print_help() -> None:
     panel = Panel(
         f"Shipit {shipit_version}",
@@ -1418,6 +1491,10 @@ def auto(
         None,
         help="The environment to use (defaults to `.env`, it will use .env.<env_name> if provided)",
     ),
+    use_provider: Optional[str] = typer.Option(
+        None,
+        help="Use a specific provider to build the project.",
+    ),
 ):
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
@@ -1430,6 +1507,7 @@ def auto(
             install_command=install_command,
             build_command=build_command,
             start_command=start_command,
+            use_provider=use_provider,
         )
 
     build(
@@ -1488,6 +1566,10 @@ def generate(
         None,
         help="The start command to use (overwrites the default)",
     ),
+    use_provider: Optional[str] = typer.Option(
+        None,
+        help="Use a specific provider to build the project.",
+    ),
 ):
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
@@ -1518,7 +1600,7 @@ def generate(
         custom_commands.install = install_command
     if build_command:
         custom_commands.build = build_command
-    content = generate_shipit(path, custom_commands)
+    content = generate_shipit(path, custom_commands, use_provider=use_provider)
     out.write_text(content)
     console.print(f"[bold]Generated Shipit[/bold] at {out.absolute()}")
 
@@ -1528,7 +1610,8 @@ def generate(
     context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
 )
 def _default(ctx: typer.Context) -> None:
-    print_help()
+    if ctx.invoked_subcommand is None:
+        print_help()
 
 
 @app.command(name="deploy")
@@ -1612,6 +1695,103 @@ def serve(
             raise Exception("Wasmer deploy is only supported for Wasmer builders")
 
 
+@app.command(name="plan")
+def plan(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Project path (defaults to current directory).",
+        show_default=False,
+    ),
+    wasmer: bool = typer.Option(
+        False,
+        help="Use Wasmer to evaluate the project.",
+    ),
+    wasmer_bin: Optional[Path] = typer.Option(
+        None,
+        help="The path to the Wasmer binary.",
+    ),
+    wasmer_registry: Optional[str] = typer.Option(
+        None,
+        help="Wasmer registry.",
+    ),
+    wasmer_token: Optional[str] = typer.Option(
+        None,
+        help="Wasmer token.",
+    ),
+    docker: bool = typer.Option(
+        False,
+        help="Use Docker to evaluate the project.",
+    ),
+    docker_client: Optional[str] = typer.Option(
+        None,
+        help="Use a specific Docker client (such as depot, podman, etc.)",
+    ),
+) -> None:
+    if not path.exists():
+        raise Exception(f"The path {path} does not exist")
+
+    custom_commands = CustomCommands()
+    procfile_path = path / "Procfile"
+    if procfile_path.exists():
+        try:
+            procfile = Procfile.loads(procfile_path.read_text())
+            custom_commands.start = procfile.get_start_command()
+        except Exception:
+            pass
+
+    builder: Builder
+    if docker or docker_client:
+        builder = DockerBuilder(path, docker_client)
+    else:
+        builder = LocalBuilder(path)
+    if wasmer:
+        builder = WasmerBuilder(
+            builder, path, registry=wasmer_registry, token=wasmer_token, bin=wasmer_bin
+        )
+
+    ctx, serve = evaluate_shipit(path, builder)
+    metadata_commands: Dict[str, Optional[str]] = {
+        "start": serve.commands.get("start"),
+        "after_deploy": serve.commands.get("after_deploy"),
+    }
+
+    def _collect_group_commands(group: str) -> Optional[str]:
+        commands = [
+            step.command
+            for step in serve.build
+            if isinstance(step, RunStep) and step.group == group
+        ]
+        if not commands:
+            return None
+        return " && ".join(commands)
+
+    metadata_install = _collect_group_commands("install")
+    metadata_build = _collect_group_commands("build")
+    metadata_commands["install"] = metadata_install
+    metadata_commands["build"] = metadata_build
+    platform: Optional[str]
+    try:
+        provider_cls = detect_provider(path, custom_commands)
+        provider_instance = provider_cls(path, custom_commands)
+        provider_instance.initialize()
+        platform = provider_instance.platform()
+    except Exception:
+        platform = None
+    plan_output = {
+        "provider": serve.provider,
+        "metadata": {
+            "platform": platform,
+            "commands": metadata_commands,
+        },
+        "config": sorted(ctx.getenv_variables),
+        "services": [
+            {"name": svc.name, "provider": svc.provider}
+            for svc in (serve.services or [])
+        ],
+    }
+    print(json.dumps(plan_output, indent=4))
+
+
 @app.command(name="build")
 def build(
     path: Path = typer.Argument(
@@ -1659,12 +1839,6 @@ def build(
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
 
-    ab_file = path / "Shipit"
-    if not ab_file.exists():
-        raise FileNotFoundError(
-            f"Shipit file not found at {ab_file}. Run `shipit generate {path}` to create it."
-        )
-    source = open(ab_file).read()
     builder: Builder
     if docker or docker_client:
         builder = DockerBuilder(path, docker_client)
@@ -1675,30 +1849,7 @@ def build(
             builder, path, registry=wasmer_registry, token=wasmer_token, bin=wasmer_bin
         )
 
-    ctx = Ctx(builder)
-    glb = sl.Globals.standard()
-    mod = sl.Module()
-
-    mod.add_callable("service", ctx.service)
-    mod.add_callable("getenv", ctx.getenv)
-    mod.add_callable("dep", ctx.dep)
-    mod.add_callable("serve", ctx.serve)
-    mod.add_callable("run", ctx.run)
-    mod.add_callable("mount", ctx.mount)
-    mod.add_callable("volume", ctx.volume)
-    mod.add_callable("workdir", ctx.workdir)
-    mod.add_callable("copy", ctx.copy)
-    mod.add_callable("path", ctx.path)
-    mod.add_callable("env", ctx.env)
-    mod.add_callable("use", ctx.use)
-
-    dialect = sl.Dialect.extended()
-    dialect.enable_f_strings = True
-
-    ast = sl.parse("shipit", source, dialect=dialect)
-
-    sl.eval(mod, ast, glb)
-    assert len(ctx.serves) <= 1, "Only one serve is allowed for now"
+    ctx, serve = evaluate_shipit(path, builder)
     env = {
         "PATH": "",
         "COLORTERM": os.environ.get("COLORTERM", ""),
@@ -1706,7 +1857,6 @@ def build(
         "LS_COLORS": os.environ.get("LS_COLORS", "0"),
         "CLICOLOR": os.environ.get("CLICOLOR", "0"),
     }
-    serve = next(iter(ctx.serves.values()))
 
     if skip_docker_if_safe_build and serve.build and len(serve.build) > 0:
         # If it doesn't have a run step, then it's safe to skip Docker and run all the

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/generator.py

@@ -64,27 +64,39 @@ def _emit_dependencies_declarations(
         declared.add(alias)
 
         version_var = None
+        architecture_var = None
         if dep.env_var:
             default = f' or "{dep.default_version}"' if dep.default_version else ""
             version_key = alias + "_version"
             lines.append(f'{version_key} = getenv("{dep.env_var}"){default}')
             version_var = version_key
+        if dep.architecture_var:
+            architecture_key = alias + "_architecture"
+            lines.append(f'{architecture_key} = getenv("{dep.architecture_var}")')
+            architecture_var = architecture_key
+        vars = [f'"{dep.name}"']
         if version_var:
-            lines.append(f'{alias} = dep("{dep.name}", {version_var})')
-        else:
-            lines.append(f'{alias} = dep("{dep.name}")')
+            vars.append(version_var)
+        if architecture_var:
+            vars.append(f"architecture={architecture_var}")
+        lines.append(f"{alias} = dep({', '.join(vars)})")
 
     return "\n".join(lines), serve_vars, build_vars
 
 
-def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
-    provider_cls = detect_provider(path, custom_commands)
+def generate_shipit(path: Path, custom_commands: CustomCommands, use_provider: Optional[str] = None) -> str:
+    provider_cls = None
+    if use_provider:
+        provider_cls = next((p for p in _providers() if p.name().lower() == use_provider.lower()), None)
+    if not provider_cls:
+        provider_cls = detect_provider(path, custom_commands)
     provider = provider_cls(path, custom_commands)
 
     # Collect parts
     plan = ProviderPlan(
         serve_name=provider.serve_name(),
         provider=provider.provider_kind(),
+        platform=provider.platform(),
         mounts=provider.mounts(),
         volumes=provider.volumes(),
         declarations=provider.declarations(),
@@ -109,7 +121,9 @@ def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
 
     build_steps_block = ",\n".join([f"    {s}" for s in build_steps])
     deps_array = ", ".join(serve_dep_vars)
-    commands_lines = ",\n".join([f'    "{k}": {v}.replace("$PORT", PORT)' for k, v in plan.commands.items()])
+    commands_lines = ",\n".join(
+        [f'    "{k}": {v}.replace("$PORT", PORT)' for k, v in plan.commands.items()]
+    )
     env_lines = None
     if plan.env is not None:
         if len(plan.env) == 0:
@@ -137,24 +151,26 @@ def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
         out.append("")
 
     for m in plan.mounts:
-        out.append(f"{m.name} = mount(\"{m.name}\")")
+        out.append(f'{m.name} = mount("{m.name}")')
         out.append("")
 
     if plan.volumes:
         for v in plan.volumes:
-            out.append(f"{v.var_name or v.name} = volume(\"{v.name}\", {v.serve_path})")
+            out.append(f'{v.var_name or v.name} = volume("{v.name}", {v.serve_path})')
         out.append("")
 
     if plan.services:
         for s in plan.services:
-            out.append(f"{s.name} = service(\n  name=\"{s.name}\",\n  provider=\"{s.provider}\"\n)")
+            out.append(
+                f'{s.name} = service(\n  name="{s.name}",\n  provider="{s.provider}"\n)'
+            )
         out.append("")
 
-    out.append("PORT = getenv(\"PORT\") or\"8080\"")
+    out.append('PORT = getenv("PORT") or "8080"')
 
     if plan.declarations:
         out.append(plan.declarations)
-    
+
     out.append("")
     out.append("serve(")
     out.append(f'  name="{plan.serve_name}",')

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/base.py

@@ -29,6 +29,7 @@ class Provider(Protocol):
     # Structured plan steps (no path args; use self.path)
     def serve_name(self) -> str: ...
     def provider_kind(self) -> str: ...
+    def platform(self) -> Optional[str]: ...
     def dependencies(self) -> list["DependencySpec"]: ...
     def declarations(self) -> Optional[str]: ...
     def build_steps(self) -> list[str]: ...
@@ -46,6 +47,7 @@ class DependencySpec:
     name: str
     env_var: Optional[str] = None
     default_version: Optional[str] = None
+    architecture_var: Optional[str] = None
     alias: Optional[str] = None  # Variable name in Shipit plan
     use_in_build: bool = False
     use_in_serve: bool = False
@@ -77,6 +79,7 @@ class ProviderPlan:
     serve_name: str
     provider: str
     mounts: List[MountSpec]
+    platform: Optional[str] = None
     volumes: List[VolumeSpec] = field(default_factory=list)
     declarations: Optional[str] = None
     dependencies: List[DependencySpec] = field(default_factory=list)
@@ -89,16 +92,3 @@ class ProviderPlan:
 
 def _exists(path: Path, *candidates: str) -> bool:
     return any((path / c).exists() for c in candidates)
-
-
-def _has_dependency(pkg_json: Path, dep: str) -> bool:
-    try:
-        import json
-
-        data = json.loads(pkg_json.read_text())
-        for section in ("dependencies", "devDependencies", "peerDependencies"):
-            if dep in data.get(section, {}):
-                return True
-    except Exception:
-        return False
-    return False

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/hugo.py

@@ -30,6 +30,9 @@ class HugoProvider(StaticFileProvider):
     def provider_kind(self) -> str:
         return "staticsite"
 
+    def platform(self) -> Optional[str]:
+        return "hugo"
+
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/laravel.py

@@ -39,6 +39,9 @@ class LaravelProvider:
     def provider_kind(self) -> str:
         return "php"
 
+    def platform(self) -> Optional[str]:
+        return "laravel"
+
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/mkdocs.py

@@ -43,6 +43,9 @@ class MkdocsProvider(StaticFileProvider):
     def provider_kind(self) -> str:
         return "mkdocs-site"
 
+    def platform(self) -> Optional[str]:
+        return "mkdocs"
+
     def dependencies(self) -> list[DependencySpec]:
         return [
             *self.python_provider.dependencies(),

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/node_static.py

@@ -122,6 +122,7 @@ class NodeStaticProvider(StaticFileProvider):
 
     def __init__(self, path: Path, custom_commands: CustomCommands):
         super().__init__(path, custom_commands)
+        self.static_generator: Optional[StaticGenerator] = None
         if (path / "package-lock.json").exists():
             self.package_manager = PackageManager.NPM
         elif (path / "pnpm-lock.yaml").exists():
@@ -233,6 +234,9 @@ class NodeStaticProvider(StaticFileProvider):
     def provider_kind(self) -> str:
         return "staticsite"
 
+    def platform(self) -> Optional[str]:
+        return self.static_generator.value if self.static_generator else None
+
     def dependencies(self) -> list[DependencySpec]:
         package_manager_dep = self.package_manager.as_dependency(self.path)
         package_manager_dep.use_in_build = True

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/php.py

@@ -20,19 +20,30 @@ class PhpProvider:
     def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
         self.custom_commands = custom_commands
-    
+        self.has_composer = _exists(self.path, "composer.json", "composer.lock") or (
+            custom_commands.install and custom_commands.install.startswith("composer ")
+        )
+
     @classmethod
     def name(cls) -> str:
         return "php"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(
+        cls, path: Path, custom_commands: CustomCommands
+    ) -> Optional[DetectResult]:
         if _exists(path, "composer.json") and _exists(path, "public/index.php"):
             return DetectResult(cls.name(), 60)
-        if _exists(path, "index.php") or _exists(path, "public/index.php") or _exists(path, "app/index.php"):
+        if (
+            _exists(path, "index.php")
+            or _exists(path, "public/index.php")
+            or _exists(path, "app/index.php")
+        ):
             return DetectResult(cls.name(), 10)
         if custom_commands.start and custom_commands.start.startswith("php "):
             return DetectResult(cls.name(), 70)
+        if custom_commands.install and custom_commands.install.startswith("composer "):
+            return DetectResult(cls.name(), 30)
         return None
 
     def initialize(self) -> None:
@@ -44,8 +55,8 @@ class PhpProvider:
     def provider_kind(self) -> str:
         return "php"
 
-    def has_composer(self) -> bool:
-        return _exists(self.path, "composer.json", "composer.lock")
+    def platform(self) -> Optional[str]:
+        return None
 
     def dependencies(self) -> list[DependencySpec]:
         deps = [
@@ -53,32 +64,39 @@ class PhpProvider:
                 "php",
                 env_var="SHIPIT_PHP_VERSION",
                 default_version="8.3",
+                architecture_var="SHIPIT_PHP_ARCHITECTURE",
                 use_in_build=True,
                 use_in_serve=True,
             ),
         ]
-        if self.has_composer():
+        if self.has_composer:
             deps.append(DependencySpec("composer", use_in_build=True))
             deps.append(DependencySpec("bash", use_in_serve=True))
         return deps
 
     def declarations(self) -> Optional[str]:
-        return "HOME = getenv(\"HOME\")\n"
+        if self.has_composer:
+            return 'HOME = getenv("HOME")\n'
+        return None
 
     def build_steps(self) -> list[str]:
         steps = [
-            "workdir(app[\"build\"])",
+            'workdir(app["build"])',
         ]
         if _exists(self.path, "php.ini"):
             steps.append('copy("php.ini", "{}/php.ini".format(assets["build"]))')
         else:
-            steps.append('copy("php/php.ini", "{}/php.ini".format(assets["build"]), base="assets")')
+            steps.append(
+                'copy("php/php.ini", "{}/php.ini".format(assets["build"]), base="assets")'
+            )
 
-        if self.has_composer():
-            steps.append("env(HOME=HOME, COMPOSER_FUND=\"0\")")
-            steps.append("run(\"composer install --optimize-autoloader --no-scripts --no-interaction\", inputs=[\"composer.json\", \"composer.lock\"], outputs=[\".\"], group=\"install\")")
+        if self.has_composer:
+            steps.append('env(HOME=HOME, COMPOSER_FUND="0")')
+            steps.append(
+                'run("composer install --optimize-autoloader --no-scripts --no-interaction", inputs=["composer.json", "composer.lock"], outputs=["."], group="install")'
+            )
 
-        steps.append("copy(\".\", \".\", ignore=[\".git\"])")
+        steps.append('copy(".", ".", ignore=[".git"])')
         return steps
 
     def prepare_steps(self) -> Optional[list[str]]:
@@ -92,12 +110,18 @@ class PhpProvider:
 
     def base_commands(self) -> Dict[str, str]:
         if _exists(self.path, "public/index.php"):
-            return {"start": '"php -S localhost:{} -t {}/public".format(PORT, app["serve"])'}
+            return {
+                "start": '"php -S localhost:{} -t {}/public".format(PORT, app["serve"])'
+            }
         elif _exists(self.path, "app/index.php"):
-            return {"start": '"php -S localhost:{} -t {}/app".format(PORT, app["serve"])'}
+            return {
+                "start": '"php -S localhost:{} -t {}/app".format(PORT, app["serve"])'
+            }
         elif _exists(self.path, "index.php"):
             return {"start": '"php -S localhost:{} -t {}".format(PORT, app["serve"])'}
-        return {}
+        return {
+            "start": '"php -S localhost:{} -t {}".format(PORT, app["serve"])',
+        }
 
     def mounts(self) -> list[MountSpec]:
         return [
@@ -112,6 +136,6 @@ class PhpProvider:
         return {
             "PHP_INI_SCAN_DIR": '"{}".format(assets["serve"])',
         }
-    
+
     def services(self) -> list[ServiceSpec]:
         return []

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/python.py

@@ -216,7 +216,7 @@ class PythonProvider:
                 return DetectResult(cls.name(), 70)
             return DetectResult(cls.name(), 50)
         if custom_commands.start:
-            if custom_commands.start.startswith("python ") or custom_commands.start.startswith("uv ") or custom_commands.start.startswith("uvicorn "):
+            if custom_commands.start.startswith("python ") or custom_commands.start.startswith("uv ") or custom_commands.start.startswith("uvicorn ") or custom_commands.start.startswith("gunicorn "):
                 return DetectResult(cls.name(), 80)
         return None
 
@@ -229,6 +229,9 @@ class PythonProvider:
     def provider_kind(self) -> str:
         return "python"
 
+    def platform(self) -> Optional[str]:
+        return self.framework.value if self.framework else None
+
     def dependencies(self) -> list[DependencySpec]:
         deps = [
             DependencySpec(
@@ -307,9 +310,9 @@ class PythonProvider:
             # Join inputs
             inputs = ", ".join([f'"{input}"' for input in input_files])
             steps += [
-                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"])',
+                'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"], UV_PYTHON_PREFERENCE="only-system", UV_PYTHON=f"python{python_version}")',
                 'copy(".", ".")' if self.install_requires_all_files else None,
-                f'run(f"uv sync --compile --python python{{python_version}} --no-managed-python{extra_args}", inputs=[{inputs}], group="install")',
+                f'run(f"uv sync{extra_args}", inputs=[{inputs}], group="install")',
                 'copy("pyproject.toml", "pyproject.toml")'
                 if not self.install_requires_all_files
                 else None,
@@ -317,14 +320,14 @@ class PythonProvider:
             ]
             if not self.only_build:
                 steps += [
-                    'run(f"uv pip compile pyproject.toml --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --no-deps -o cross-requirements.txt", outputs=["cross-requirements.txt"]) if cross_platform else None',
+                    'run(f"uv pip compile pyproject.toml --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --no-deps -o cross-requirements.txt", outputs=["cross-requirements.txt"]) if cross_platform else None',
                     f'run(f"uvx pip install -r cross-requirements.txt {extra_deps} --target {{python_cross_packages_path}} --platform {{cross_platform}} --only-binary=:all: --python-version={{python_version}} --compile") if cross_platform else None',
                     'run("rm cross-requirements.txt") if cross_platform else None',
                 ]
         elif has_requirements or extra_deps:
             steps += [
                 'env(UV_PROJECT_ENVIRONMENT=local_venv["build"] if cross_platform else venv["build"])',
-                'run(f"uv init --no-workspace --no-managed-python --python python{python_version}", inputs=[], outputs=["uv.lock"], group="install")',
+                'run(f"uv init --no-workspace", inputs=[], outputs=["uv.lock"], group="install")',
                 'copy(".", ".")' if self.install_requires_all_files else None,
             ]
             if has_requirements:
@@ -351,6 +354,10 @@ class PythonProvider:
                 'run("mkdir -p {}/bin".format(venv["build"])) if cross_platform else None',
                 'run("cp {}/bin/mcp {}/bin/mcp".format(local_venv["build"], venv["build"])) if cross_platform else None',
             ]
+        if self.framework == PythonFramework.Django:
+            steps += [
+                'run("python manage.py collectstatic --noinput", group="build")',
+            ]
         return list(filter(None, steps))
 
     def prepare_steps(self) -> Optional[list[str]]:

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/registry.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from .base import Provider
-from .gatsby import GatsbyProvider
 from .hugo import HugoProvider
 from .laravel import LaravelProvider
 from .mkdocs import MkdocsProvider
@@ -16,7 +15,6 @@ def providers() -> list[type[Provider]]:
     # Order matters: more specific providers first
     return [
         LaravelProvider,
-        # GatsbyProvider,
         HugoProvider,
         MkdocsProvider,
         PythonProvider,

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/staticfile.py

@@ -61,6 +61,9 @@ class StaticFileProvider:
     def provider_kind(self) -> str:
         return "staticfile"
 
+    def platform(self) -> Optional[str]:
+        return None
+
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(

{shipit_cli-0.10.1 → shipit_cli-0.11.1}/src/shipit/providers/wordpress.py

@@ -19,8 +19,7 @@ from .php import PhpProvider
 
 class WordPressProvider(PhpProvider):
     def __init__(self, path: Path, custom_commands: CustomCommands):
-        self.path = path
-        self.custom_commands = custom_commands
+        super().__init__(path, custom_commands)
 
     @classmethod
     def name(cls) -> str:
@@ -47,6 +46,9 @@ class WordPressProvider(PhpProvider):
     def provider_kind(self) -> str:
         return "php"
 
+    def platform(self) -> Optional[str]:
+        return "wordpress"
+
     def dependencies(self) -> list[DependencySpec]:
         return [
             *super().dependencies(),
@@ -54,7 +56,7 @@ class WordPressProvider(PhpProvider):
         ]
 
     def declarations(self) -> Optional[str]:
-        return super().declarations() + (
+        return (super().declarations() or "") + (
             'wp_cli_version = getenv("SHIPIT_WPCLI_VERSION")\n'
             "if wp_cli_version:\n"
             '    wp_cli_download_url = f"https://github.com/wp-cli/wp-cli/releases/download/v{wp_cli_version}/wp-cli-{wp_cli_version}.phar"\n'
@@ -65,7 +67,7 @@ class WordPressProvider(PhpProvider):
     def build_steps(self) -> list[str]:
         steps = [
             'copy(wp_cli_download_url, "{}/wp-cli.phar".format(assets["build"]))',
-            'copy("wordpress/install.sh", "{}/wordpress-install.sh".format(assets["build"]), base="assets")',
+            'copy("wordpress/install.sh", "{}/setup-wp.sh".format(assets["build"]), base="assets")',
         ]
         if not _exists(self.path, "wp-config.php"):
             steps.append(
@@ -80,7 +82,7 @@ class WordPressProvider(PhpProvider):
         commands = super().commands()
         return {
             "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets["serve"], app["serve"])',
-            "after_deploy": '"bash {}/wordpress-install.sh".format(assets["serve"])',
+            "after_deploy": '"bash {}/setup-wp.sh".format(assets["serve"])',
             **commands,
         }
 

shipit_cli-0.11.1/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.11.1"
+version_info = (0, 11, 1, "final", 0)

shipit_cli-0.10.1/src/shipit/providers/gatsby.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Dict, Optional
-
-from .base import (
-    DetectResult,
-    DependencySpec,
-    Provider,
-    _exists,
-    _has_dependency,
-    MountSpec,
-    ServiceSpec,
-    VolumeSpec,
-    CustomCommands,
-)
-
-
-class GatsbyProvider:
-    def __init__(self, path: Path, custom_commands: CustomCommands):
-        self.path = path
-        self.custom_commands = custom_commands
-
-    @classmethod
-    def name(cls) -> str:
-        return "gatsby"
-
-    @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
-        pkg = path / "package.json"
-        if not pkg.exists():
-            return None
-        if _exists(path, "gatsby-config.js", "gatsby-config.ts") or _has_dependency(
-            pkg, "gatsby"
-        ):
-            return DetectResult(cls.name(), 90)
-        return None
-
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def provider_kind(self) -> str:
-        return "staticsite"
-
-    def declarations(self) -> Optional[str]:
-        return None
-
-    def dependencies(self) -> list[DependencySpec]:
-        return [
-            DependencySpec(
-                "node",
-                env_var="SHIPIT_NODE_VERSION",
-                default_version="22",
-                use_in_build=True,
-            ),
-            DependencySpec("npm", use_in_build=True),
-            DependencySpec("static-web-server", env_var="SHIPIT_SWS_VERSION", use_in_serve=True),
-        ]
-
-    def build_steps(self) -> list[str]:
-        return [
-            "run(\"npm install\", inputs=[\"package.json\", \"package-lock.json\"], group=\"install\")",
-            "copy(\".\", \".\", ignore=[\"node_modules\", \".git\"])",
-            "run(\"npm run build\", outputs=[\"public\"], group=\"build\")",
-            "run(\"cp -R public/* {}/\".format(app[\"build\"]))",
-        ]
-
-    def prepare_steps(self) -> Optional[list[str]]:
-        return None
-
-    def commands(self) -> Dict[str, str]:
-        return {"start": '"static-web-server --root /app"'}
-
-    def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
-
-    def volumes(self) -> list[VolumeSpec]:
-        return []
-
-    def env(self) -> Optional[Dict[str, str]]:
-        return None
-    
-    def services(self) -> list[ServiceSpec]:
-        return []

shipit_cli-0.10.1/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.10.1"
-version_info = (0, 10, 1, "final", 0)