Do you really need a full blown (PHP) CMS for your personal Website? Here's a script that says no.

import os
import re
from urllib.parse import urljoin, urlparse
from bs4 import BeautifulSoup
import requests

# Configuration
# Point this to your local server (e.g., http://localhost/my_php_site/ or http://localhost/ if at root)
BASE_URL = "http://wherever.whatever.whoever/"
OUTPUT_DIR = "./static_site"

visited_urls = set()


def same_site(a, b):
  """Treat www.example.com and example.com as the same site."""
  na = urlparse(a).netloc.lower().removeprefix("www.")
  nb = urlparse(b).netloc.lower().removeprefix("www.")
  return na == nb

def get_absolute_url(base_url, href):
  """Robustly resolves links, ensuring subfolder paths aren't lost on root-relative links."""
  if not href:
    return None

  href = href.split("#")[0].strip()
  if not href or href.startswith(("javascript:", "mailto:", "tel:")):
    return None

  parsed_base = urlparse(BASE_URL)
  base_path = parsed_base.path.rstrip("/")  # e.g., "/my_php_site"

  # If it's already a full http/https URL
  if href.startswith("http://") or href.startswith("https://"):
    return href

  # If it's root-relative (starts with /) and base_path exists, ensure subfolder is included for fetching
  if href.startswith("/") and base_path and not href.startswith(base_path):
    return f"{parsed_base.scheme}://{parsed_base.netloc}{base_path}{href}"

  return urljoin(base_url, href)


def get_relative_subpath(url, base_url):
  """Extracts the clean relative route inside the site (e.g., node/3 -> node/3.html)."""
  parsed_url = urlparse(url)
  parsed_base = urlparse(base_url)

  if parsed_url.netloc and not same_site(url, base_url):
    return None  # External link

  path = parsed_url.path
  base_path_prefix = parsed_base.path.rstrip("/")

  # Strip base path prefix if present
  if base_path_prefix and path.startswith(base_path_prefix):
    path = path[len(base_path_prefix) :]

  path = path.lstrip("/")

  # Handle root, directories, .php files, and extensionless dynamic routes (like node/3)
  if path == "" or path.endswith("/"):
    path = path + "index.html"
  elif path.endswith(".php"):
    path = path[:-4] + ".html"
  elif not os.path.splitext(path)[1] and not path.lower().endswith(
      (
          ".css",
          ".js",
          ".png",
          ".jpg",
          ".jpeg",
          ".gif",
          ".pdf",
          ".svg",
          ".ico",
          ".json",
          ".xml",
      )
  ):
    path = path + ".html"

  return path


def get_local_path(url, base_url, output_dir):
  """Determines the absolute local file path for saving."""
  subpath = get_relative_subpath(url, base_url)
  if not subpath:
    return None
  return os.path.join(output_dir, subpath)


def get_root_relative_url(url, base_url):
  """Converts any internal URL into a clean root-relative path (e.g., /node/3.html)."""
  subpath = get_relative_subpath(url, base_url)
  if not subpath:
    return url  # External link
  return "/" + subpath

CSS_URL_RE = re.compile(r"""url\(\s*(["']?)([^)"']+)\1\s*\)""")
CSS_IMPORT_RE = re.compile(r"""@import\s+(["'])([^"']+)\1""")


def map_css_ref(raw, css_url, to_crawl):
  """Returns the rewritten root-relative URL for a CSS reference, or None to leave it untouched."""
  raw = raw.strip()
  if not raw or raw.startswith("data:"):
    return None
  absolute = get_absolute_url(css_url, raw)
  if not absolute or not same_site(absolute, BASE_URL):
    return None
  to_crawl.append(absolute)
  new_url = get_root_relative_url(absolute, BASE_URL)
  query = urlparse(raw).query
  if query:
    new_url += f"?{query}"
  return new_url


def rewrite_css(css_text, css_url, to_crawl):
  """Rewrites url(...) and @import references and collects the originals for crawling."""

  def repl_url(m):
    new = map_css_ref(m.group(2), css_url, to_crawl)
    return m.group(0) if new is None else f"url({m.group(1)}{new}{m.group(1)})"

  def repl_import(m):
    new = map_css_ref(m.group(2), css_url, to_crawl)
    return m.group(0) if new is None else f"@import {m.group(1)}{new}{m.group(1)}"

  css_text = CSS_URL_RE.sub(repl_url, css_text)
  return CSS_IMPORT_RE.sub(repl_import, css_text)

def process_and_save(url):
  """Crawls the site, saves dynamic routes into subdirectories, and rewrites links to root-relative."""
  if url in visited_urls:
    return
  visited_urls.add(url)

  print(f"Processing: {url}")
  try:
    response = requests.get(url, timeout=30)
    if response.status_code != 200:
      print(f"Skipping {url} (Status code: {response.status_code})")
      return

    content_type = response.headers.get("content-type", "").lower()
    local_path = get_local_path(url, BASE_URL, OUTPUT_DIR)
    if not local_path:
      return

    os.makedirs(os.path.dirname(local_path), exist_ok=True)

    # Check if it's an HTML page / dynamic route or a static asset (CSS, JS, Image, PDF)
    if "text/html" in content_type or not os.path.splitext(urlparse(url).path)[1]:
      html_content = response.text
      soup = BeautifulSoup(html_content, "html.parser")

      link_mappings = [
          ("a", "href"),
          ("link", "href"),
          ("script", "src"),
          ("img", "src"),
          ("source", "src"),
          ("form", "action"),
      ]

      to_crawl=[]
      # First pass: Rewrite internal links to root-relative format (e.g., /node/3.html)
      for tag_name, attr in link_mappings:
        for tag in soup.find_all(tag_name, **{attr: True}):
          attr_val = tag[attr]
          absolute_url = get_absolute_url(url, attr_val)

          if absolute_url and same_site(absolute_url, BASE_URL):
            to_crawl.append(absolute_url)
            new_url = get_root_relative_url(absolute_url, BASE_URL)

            # Preserve query parameters if they existed
            parsed_orig = urlparse(attr_val)
            if parsed_orig.query:
              new_url += f"?{parsed_orig.query}"

            tag[attr] = new_url

            # Handle <style> blocks (Drupal puts @import url(...) in here)
      for style_tag in soup.find_all("style"):
        if style_tag.string:
          style_tag.string.replace_with(rewrite_css(style_tag.string, url, to_crawl))

      # Save the modified HTML file

      with open(local_path, "w", encoding="utf-8") as f:
        f.write(str(soup))
      print(f"Saved HTML -> {local_path}")

      # Second pass: crawl the ORIGINAL remote URLs collected above
      skip_extensions = (".mp4", ".webm", ".avi", ".mov", ".mp3", ".wav")
      for target in to_crawl:
        if target in visited_urls:
          continue
        if urlparse(target).path.lower().endswith(skip_extensions):
          continue
        process_and_save(target)

    elif "text/css" in content_type or urlparse(url).path.lower().endswith(".css"):
      # CSS: rewrite internal references, then crawl what they point to
      css_targets = []
      css_text = response.content.decode("utf-8", errors="replace")
      css_text = rewrite_css(css_text, url, css_targets)
      with open(local_path, "w", encoding="utf-8") as f:
        f.write(css_text)
      print(f"Saved CSS -> {local_path}")
      for target in css_targets:
        if target not in visited_urls:
          process_and_save(target)

    else:
      # Save static binary assets (JS, images, PDFs, etc.)
      with open(local_path, "wb") as f:
        f.write(response.content)
      print(f"Saved Asset -> {local_path}")

  except Exception as e:
    print(f"Error processing {url}: {e}")


if __name__ == "__main__":
  os.makedirs(OUTPUT_DIR, exist_ok=True)
  print(f"Starting static conversion for: {BASE_URL}")
  process_and_save(BASE_URL)
  print(
      f"\nDone! Fully functional static site generated inside:"
      f" {os.path.abspath(OUTPUT_DIR)}"
  )