shipit-cli 0.1.0__py3-none-any.whl

shipit/generator.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from shipit.providers.base import DependencySpec, Provider, ProviderPlan, DetectResult
+from shipit.providers.registry import providers as registry_providers
+
+
+def _providers() -> list[Provider]:
+    # Load providers from modular registry
+    return registry_providers()
+
+
+def detect_provider(path: Path) -> Provider:
+    matches: list[tuple[Provider, DetectResult]] = []
+    for p in _providers():
+        res = p.detect(path)
+        if res:
+            matches.append((p, res))
+    if not matches:
+        # Default to static site as the safest fallback
+        from shipit.providers.staticfile import StaticFileProvider
+
+        return StaticFileProvider()
+    # Highest score wins; tie-breaker by order
+    matches.sort(key=lambda x: x[1].score, reverse=True)
+    return matches[0][0]
+
+
+def _sanitize_alias(name: str) -> str:
+    # Keep it predictable and valid in Starlark: letters, numbers, underscore
+    # Remove dashes to keep prior style (e.g., staticwebserver)
+    allowed = [c if c.isalnum() or c == "_" else "" for c in name]
+    alias = "".join(allowed)
+    return alias.replace("-", "")
+
+
+def _emit_dependencies_declarations(
+    deps: List[DependencySpec],
+) -> tuple[str, List[str], List[str]]:
+    lines: List[str] = []
+    declared: set[str] = set()
+    serve_vars: List[str] = []
+    build_vars: List[str] = []
+
+    for dep in deps:
+        alias = dep.alias or _sanitize_alias(dep.name)
+
+        # Track serve variables in order of appearance (deduped)
+        if dep.use_in_serve and alias not in serve_vars:
+            serve_vars.append(alias)
+        if dep.use_in_build and alias not in build_vars:
+            build_vars.append(alias)
+
+        # Only declare each dependency once
+        if alias in declared:
+            continue
+        declared.add(alias)
+
+        version_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 version_var:
+            lines.append(f'{alias} = dep("{dep.name}", {version_var})')
+        else:
+            lines.append(f'{alias} = dep("{dep.name}")')
+
+    return "\n".join(lines), serve_vars, build_vars
+
+
+def _render_assets(assets: Optional[Dict[str, str]]) -> Optional[str]:
+    if not assets:
+        return None
+    inner = ",\n".join([f'    "{k}": {v}' for k, v in assets.items()])
+    return f"{{\n{inner}\n  }}"
+
+
+def generate_shipit(path: Path) -> str:
+    provider = detect_provider(path)
+    provider.initialize(path)
+
+    # Collect parts
+    plan = ProviderPlan(
+        serve_name=provider.serve_name(path),
+        provider=provider.provider_kind(path),
+        declarations=provider.declarations(path),
+        dependencies=provider.dependencies(path),
+        build_steps=provider.build_steps(path),
+        prepare=provider.prepare_steps(path),
+        commands=provider.commands(path),
+        assets=provider.assets(path),
+        mounts=provider.mounts(path),
+    )
+
+    # Declare dependency variables (combined) and collect serve deps
+    dep_block, serve_dep_vars, build_dep_vars = _emit_dependencies_declarations(
+        plan.dependencies
+    )
+
+    # Compose serve(...) body
+    # Auto-insert a use(...) step at the beginning if not explicitly provided
+    build_steps: List[str] = list(plan.build_steps)
+    if build_dep_vars and not any("use(" in s for s in build_steps):
+        build_steps.insert(0, f"use({', '.join(build_dep_vars)})")
+
+    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}' for k, v in plan.commands.items()])
+    assets_block = _render_assets(plan.assets)
+    mounts_block = None
+    if plan.mounts:
+        mounts_block = ",\n".join([f"    {k}: {v}" for k, v in plan.mounts.items()])
+
+    out: List[str] = []
+    if dep_block:
+        out.append(dep_block)
+        out.append("")
+    if plan.declarations:
+        out.append(plan.declarations)
+        out.append("")
+    out.append("serve(")
+    out.append(f'  name="{plan.serve_name}",')
+    out.append(f'  provider="{plan.provider}",')
+    out.append("  build=[")
+    out.append(build_steps_block)
+    out.append("  ],")
+    if assets_block:
+        out.append("  assets=" + assets_block + ",")
+    out.append(f"  deps=[{deps_array}],")
+    if plan.prepare:
+        prepare_steps_block = ",\n".join([f"    {s}" for s in plan.prepare])
+        out.append("  prepare=[")
+        out.append(prepare_steps_block)
+        out.append("  ],")
+    out.append("  commands = {")
+    out.append(commands_lines)
+    out.append("  },")
+    if mounts_block:
+        out.append("  mounts={")
+        out.append(mounts_block)
+        out.append("  },")
+    out.append(")")
+    out.append("")
+    return "\n".join(out)

shipit/providers/base.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Protocol
+
+
+@dataclass
+class DetectResult:
+    name: str
+    score: int  # Higher score wins when multiple providers match
+
+
+class Provider(Protocol):
+    def name(self) -> str: ...
+    def detect(self, path: Path) -> Optional[DetectResult]: ...
+    def initialize(self, path: Path) -> None: ...
+    # Structured plan steps
+    def serve_name(self, path: Path) -> str: ...
+    def provider_kind(self, path: Path) -> str: ...
+    def dependencies(self, path: Path) -> list["DependencySpec"]: ...
+    def declarations(self, path: Path) -> Optional[str]: ...
+    def build_steps(self, path: Path) -> list[str]: ...
+    # Prepare: list of Starlark step calls (currently only run(...))
+    def prepare_steps(self, path: Path) -> Optional[List[str]]: ...
+    def commands(self, path: Path) -> Dict[str, str]: ...
+    def assets(self, path: Path) -> Optional[Dict[str, str]]: ...
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]: ...
+
+
+@dataclass
+class DependencySpec:
+    name: str
+    env_var: Optional[str] = None
+    default_version: Optional[str] = None
+    alias: Optional[str] = None  # Variable name in Shipit plan
+    use_in_build: bool = False
+    use_in_serve: bool = False
+
+
+@dataclass
+class ProviderPlan:
+    serve_name: str
+    provider: str
+    declarations: Optional[str] = None
+    dependencies: List[DependencySpec] = field(default_factory=list)
+    build_steps: List[str] = field(default_factory=list)
+    prepare: Optional[List[str]] = None
+    commands: Dict[str, str] = field(default_factory=dict)
+    assets: Optional[Dict[str, str]] = None
+    mounts: Optional[Dict[str, str]] = None
+
+
+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/providers/gatsby.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency
+
+
+class GatsbyProvider:
+    def name(self) -> str:
+        return "gatsby"
+
+    def detect(self, path: Path) -> 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(self.name(), 90)
+        return None
+
+    def initialize(self, path: Path) -> None:
+        pass
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "staticsite"
+
+    def declarations(self, path: Path) -> Optional[str]:
+        return None
+
+    def dependencies(self, path: Path) -> 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, path: Path) -> 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\")",
+        ]
+
+    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+        return None
+
+    def commands(self, path: Path) -> Dict[str, str]:
+        return {"start": '"static-web-server --root /app/public"'}
+
+    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]:
+        return None

shipit/providers/hugo.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists
+from .staticfile import StaticFileProvider
+
+class HugoProvider(StaticFileProvider):
+    static_dir = "public"
+
+    def name(self) -> str:
+        return "hugo"
+
+    def detect(self, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "hugo.toml", "hugo.json", "hugo.yaml", "hugo.yml"):
+            return DetectResult(self.name(), 80)
+        if (
+            _exists(path, "config.toml", "config.json", "config.yaml", "config.yml")
+            and _exists(path, "content")
+            and (_exists(path, "static") or _exists(path, "themes"))
+        ):
+            return DetectResult(self.name(), 40)
+        return None
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "staticsite"
+
+    def dependencies(self, path: Path) -> list[DependencySpec]:
+        return [
+            DependencySpec(
+                "hugo",
+                env_var="SHIPIT_HUGO_VERSION",
+                default_version="0.149.0",
+                use_in_build=True,
+            ),
+            *super().dependencies(path),
+        ]
+
+    def build_steps(self, path: Path) -> list[str]:
+        return [
+            'copy(".", ".", ignore=[".git"])',
+            'run("hugo build", outputs=["public"], group="build")',
+        ]

shipit/providers/laravel.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists
+
+
+class LaravelProvider:
+    def name(self) -> str:
+        return "laravel"
+
+    def detect(self, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "artisan") and _exists(path, "composer.json"):
+            return DetectResult(self.name(), 95)
+        return None
+
+    def initialize(self, path: Path) -> None:
+        pass
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "php"
+
+    def dependencies(self, path: Path) -> list[DependencySpec]:
+        return [
+            DependencySpec(
+                "php",
+                env_var="SHIPIT_PHP_VERSION",
+                default_version="8.3",
+                use_in_build=True,
+                use_in_serve=True,
+            ),
+            DependencySpec("composer", use_in_build=True),
+            DependencySpec("pie", use_in_build=True),
+            DependencySpec("pnpm", use_in_build=True),
+            DependencySpec("bash", use_in_serve=True),
+        ]
+
+    def declarations(self, path: Path) -> Optional[str]:
+        return "HOME = getenv(\"HOME\")"
+
+    def build_steps(self, path: Path) -> list[str]:
+        return [
+            "env(HOME=HOME, COMPOSER_FUND=\"0\")",
+            "run(\"pie install php/pdo_pgsql\")",
+            "run(\"composer install --optimize-autoloader --no-scripts --no-interaction\", inputs=[\"composer.json\", \"composer.lock\", \"artisan\"], outputs=[\".\"], group=\"install\")",
+            "run(\"pnpm install\", inputs=[\"package.json\", \"package-lock.json\"], outputs=[\".\"], group=\"install\")",
+            "copy(\".\", \".\", ignore=[\".git\"])",
+            "run(\"pnpm run build\", outputs=[\".\"], group=\"build\")",
+        ]
+
+    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+        return [
+            'run("mkdir -p storage/framework/{sessions,views,cache,testing} storage/logs bootstrap/cache")',
+            'run("php artisan config:cache")',
+            'run("php artisan event:cache")',
+            'run("php artisan route:cache")',
+            'run("php artisan view:cache")',
+        ]
+
+    def commands(self, path: Path) -> Dict[str, str]:
+        return {
+            "start": '"php -S localhost:8080 -t public"',
+            "after_deploy": '"php artisan migrate"',
+        }
+
+    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]:
+        return None

shipit/providers/mkdocs.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists
+
+
+class MkdocsProvider:
+    def name(self) -> str:
+        return "mkdocs"
+
+    def detect(self, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
+            return DetectResult(self.name(), 85)
+        return None
+
+    def initialize(self, path: Path) -> None:
+        pass
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "mkdocs-site"
+
+    def dependencies(self, path: Path) -> list[DependencySpec]:
+        return [
+            DependencySpec(
+                "python",
+                env_var="SHIPIT_PYTHON_VERSION",
+                default_version="3.13",
+                use_in_build=True,
+            ),
+            DependencySpec(
+                "uv",
+                env_var="SHIPIT_UV_VERSION",
+                default_version="0.8.15",
+                use_in_build=True,
+            ),
+            DependencySpec(
+                "static-web-server",
+                env_var="SHIPIT_SWS_VERSION",
+                default_version="2.38.0",
+                use_in_serve=True,
+            ),
+        ]
+
+    def declarations(self, path: Path) -> Optional[str]:
+        return None
+
+    def build_steps(self, path: Path) -> list[str]:
+        has_requirements = _exists(path, "requirements.txt")
+        if has_requirements:
+            install_lines = [
+                "run(\"uv init --no-managed-python\", inputs=[], outputs=[\".\"], group=\"install\")",
+                "run(f\"uv add -r requirements.txt\", inputs=[\"requirements.txt\"], outputs=[\".venv\"], group=\"install\")",
+            ]
+        else:
+            install_lines = [
+                "mkdocs_version = getenv(\"SHIPIT_MKDOCS_VERSION\") or \"1.6.1\"",
+                "run(\"uv init --no-managed-python\", inputs=[], outputs=[\".venv\"], group=\"install\")",
+                "run(f\"uv add mkdocs=={mkdocs_version}\", group=\"install\")",
+            ]
+        return [
+            *install_lines,
+            "copy(\".\", \".\", ignore=[\".venv\", \".git\", \"__pycache__\"])",
+            "run(\"uv run mkdocs build\", outputs=[\".\"], group=\"build\")",
+        ]
+
+    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+        return None
+
+    def commands(self, path: Path) -> Dict[str, str]:
+        return {"start": '"static-web-server --root {}".format(buildpath("site"))'}
+
+    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]:
+        return None

shipit/providers/node_static.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency
+
+
+class NodeStaticProvider:
+    def name(self) -> str:
+        return "node-static"
+
+    def detect(self, path: Path) -> Optional[DetectResult]:
+        pkg = path / "package.json"
+        if not pkg.exists():
+            return None
+        static_generators = ["astro", "vite", "next", "nuxt"]
+        if any(_has_dependency(pkg, dep) for dep in static_generators):
+            return DetectResult(self.name(), 40)
+        return None
+
+    def initialize(self, path: Path) -> None:
+        pass
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "staticsite"
+
+    def dependencies(self, path: Path) -> 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", use_in_serve=True),
+        ]
+
+    def declarations(self, path: Path) -> Optional[str]:
+        return None
+
+    def build_steps(self, path: Path) -> list[str]:
+        output_dir = "dist" if (path / "dist").exists() else "public"
+        return [
+            "run(\"npm install\", inputs=[\"package.json\", \"package-lock.json\"], group=\"install\")",
+            "copy(\".\", \".\", ignore=[\"node_modules\", \".git\"])",
+            f"run(\"npm run build\", outputs=[\"{output_dir}\"], group=\"build\")",
+        ]
+
+    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+        return None
+
+    def commands(self, path: Path) -> Dict[str, str]:
+        output_dir = "dist" if (path / "dist").exists() else "public"
+        return {"start": f'"static-web-server --root /app/{output_dir}"'}
+
+    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+        return None
+
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]:
+        return None

shipit/providers/php.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from .base import DetectResult, DependencySpec, Provider, _exists
+
+
+class PhpProvider:
+    def name(self) -> str:
+        return "php"
+
+    def detect(self, path: Path) -> Optional[DetectResult]:
+        if _exists(path, "composer.json") and _exists(path, "public/index.php"):
+            return DetectResult(self.name(), 60)
+        if _exists(path, "index.php") and not _exists(path, "composer.json"):
+            return DetectResult(self.name(), 10)
+        return None
+
+    def initialize(self, path: Path) -> None:
+        pass
+
+    def serve_name(self, path: Path) -> str:
+        return path.name
+
+    def provider_kind(self, path: Path) -> str:
+        return "php"
+
+    def has_composer(self, path: Path) -> bool:
+        return _exists(path, "composer.json", "composer.lock")
+
+    def dependencies(self, path: Path) -> list[DependencySpec]:
+        deps = [
+            DependencySpec(
+                "php",
+                env_var="SHIPIT_PHP_VERSION",
+                default_version="8.3",
+                use_in_build=True,
+                use_in_serve=True,
+            ),
+        ]
+        if self.has_composer(path):
+            deps.append(DependencySpec("composer", use_in_build=True))
+            deps.append(DependencySpec("bash", use_in_serve=True))
+        return deps
+
+    def declarations(self, path: Path) -> Optional[str]:
+        return "HOME = getenv(\"HOME\")"
+
+    def build_steps(self, path: Path) -> list[str]:
+        steps = []
+
+        if self.has_composer(path):
+            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\"])")
+        return steps
+
+    def prepare_steps(self, path: Path) -> Optional[list[str]]:
+        return None
+
+    def commands(self, path: Path) -> Dict[str, str]:
+        if _exists(path, "public/index.php"):
+            return {"start": '"php -S localhost:8080 -t public"'}
+        elif _exists(path, "index.php"):
+            return {"start": '"php -S localhost:8080" -t .'}
+
+    def assets(self, path: Path) -> Optional[Dict[str, str]]:
+        return {"php.ini": "get_asset(\"php/php.ini\")"}
+
+    def mounts(self, path: Path) -> Optional[Dict[str, str]]:
+        return None