stapler-ssg 0.1.2__py3-none-any.whl

stapler/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

stapler/cli.py

@@ -0,0 +1,72 @@
+import argparse
+import sys
+
+from colorama import init
+
+from .config import load_config
+from .core.engine import build_site
+from .server import serve
+
+init()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Stapler - A flexible static site generator",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "command",
+        nargs="?",
+        default="build",
+        choices=["build", "serve"],
+        help="Command to run (default: build)",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        default="stapler.toml",
+        help="Path to configuration file (default: stapler.toml)",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for development server (default: 8000)",
+    )
+
+    parser.add_argument(
+        "--version",
+        action="store_true",
+        help="Show version and exit",
+    )
+
+    args = parser.parse_args()
+
+    if args.version:
+        from . import __version__
+
+        print(f"Stapler {__version__}")
+        sys.exit(0)
+
+    try:
+        config = load_config(args.config)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    except ValueError as e:
+        print(f"Configuration error: {e}")
+        sys.exit(1)
+
+    if args.command == "serve":
+        serve(config, args.port)
+    else:
+        build_site(config)
+
+
+if __name__ == "__main__":
+    main()

stapler/config.py

@@ -0,0 +1,122 @@
+import os
+import tomllib
+from pathlib import Path
+
+import yaml
+
+
+def load_config(config_path="stapler.toml"):
+    path = Path(config_path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {path}")
+
+    if path.suffix == ".toml":
+        with open(path, "rb") as f:
+            config = tomllib.load(f)
+    elif path.suffix in [".yaml", ".yml"]:
+        with open(path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        raise ValueError(f"Unsupported config format: {path.suffix}. Use .toml or .yaml")
+
+    site = config.get("site", {})
+    if not site.get("url"):
+        raise ValueError("site.url is required in configuration")
+    if not site.get("title"):
+        raise ValueError("site.title is required in configuration")
+
+    return config
+
+
+def get_site_dir(config):
+    return config.get("directories", {}).get("site", "site")
+
+
+def get_build_dir(config):
+    return config.get("directories", {}).get("build", "build")
+
+
+def get_build_dev_dir(config):
+    return config.get("directories", {}).get("build_dev", "build-dev")
+
+
+def get_templates_dir(config):
+    templates = config.get("directories", {}).get("templates", "templates")
+    return os.path.join(get_site_dir(config), templates)
+
+
+def get_blog_dir(config):
+    if not has_blog(config):
+        return None
+    blog = config.get("directories", {}).get("blog", "blog")
+    return os.path.join(get_site_dir(config), blog)
+
+
+def has_blog(config):
+    return config.get("features", {}).get("blog", {}).get("enabled", False)
+
+
+def has_sitemap(config):
+    return config.get("features", {}).get("sitemap", True)
+
+
+def has_feeds(config):
+    feeds_config = config.get("features", {}).get("feeds", True)
+    if isinstance(feeds_config, bool):
+        return feeds_config and has_blog(config)
+    return (feeds_config.get("rss", True) or feeds_config.get("atom", True)) and has_blog(config)
+
+
+def get_feed_formats(config):
+    if not has_feeds(config):
+        return []
+    feeds_config = config.get("features", {}).get("feeds", True)
+    if isinstance(feeds_config, bool):
+        return ["rss", "atom"] if feeds_config else []
+    formats = []
+    if feeds_config.get("rss", True):
+        formats.append("rss")
+    if feeds_config.get("atom", True):
+        formats.append("atom")
+    return formats
+
+
+def get_base_path(config):
+    return config.get("site", {}).get("base_path", "")
+
+
+def get_site_url(config):
+    return config["site"]["url"]
+
+
+def get_site_title(config):
+    return config["site"]["title"]
+
+
+def get_site_description(config):
+    return config.get("site", {}).get("description", "")
+
+
+def get_author_name(config):
+    return config.get("site", {}).get("author", {}).get("name", "")
+
+
+def get_author_email(config):
+    return config.get("site", {}).get("author", {}).get("email", "")
+
+
+def get_markdown_extensions(config):
+    return config.get("markdown", {}).get("extensions", ["meta", "tables", "fenced_code"])
+
+
+def get_blog_template(config):
+    return config.get("features", {}).get("blog", {}).get("template", "blog_post.html")
+
+
+def get_blog_index_template(config):
+    return config.get("features", {}).get("blog", {}).get("index_template", "blog_index.html")
+
+
+def get_default_template(config):
+    return config.get("templates", {}).get("default", "base.html")

stapler/core/engine.py

@@ -0,0 +1,184 @@
+import os
+import shutil
+import tempfile
+import time
+
+from colorama import Fore, Style
+from jinja2 import Environment, FileSystemLoader
+from markdown import Markdown
+
+from .. import config as cfg
+from ..plugins import blog, sitemap
+from .utils import get_data, infer_page_metadata, parse_front_matter, warn
+
+
+def build_site(config, output_dir=None, is_dev=False):
+    if output_dir is None:
+        output_dir = cfg.get_build_dev_dir(config) if is_dev else cfg.get_build_dir(config)
+
+    start_time = time.time()
+    print(f"{Fore.CYAN}=> Building site <={Style.RESET_ALL}")
+
+    print("> Setting up environment... ", end="", flush=True)
+    setup_start = time.time()
+    temp_build_dir = tempfile.mkdtemp()
+
+    loader_paths = [cfg.get_site_dir(config)]
+    templates_dir = cfg.get_templates_dir(config)
+    if os.path.exists(templates_dir):
+        loader_paths.append(templates_dir)
+    template_env = Environment(loader=FileSystemLoader(loader_paths))
+
+    md_processor = Markdown(extensions=cfg.get_markdown_extensions(config))
+    data = get_data()
+
+    setup_time = time.time() - setup_start
+    print(f"{Fore.GREEN}done ({setup_time * 1000:.0f}ms){Style.RESET_ALL}")
+
+    posts = []
+    if cfg.has_blog(config):
+        print("> Processing blog posts... ", end="", flush=True)
+        blog_start = time.time()
+        posts = blog.process_blog(config, template_env, md_processor, data, temp_build_dir)
+        blog_time = time.time() - blog_start
+        print(f"{Fore.GREEN}{len(posts)} posts ({blog_time * 1000:.0f}ms){Style.RESET_ALL}")
+
+    print("> Processing site files... ", end="", flush=True)
+    files_start = time.time()
+    _process_site_files(config, template_env, md_processor, data, temp_build_dir)
+    files_time = time.time() - files_start
+    print(f"{Fore.GREEN}done ({files_time * 1000:.0f}ms){Style.RESET_ALL}")
+
+    if cfg.has_sitemap(config):
+        print("> Generating sitemap... ", end="", flush=True)
+        sitemap_start = time.time()
+        sitemap.generate_sitemap(config, temp_build_dir, posts)
+        sitemap_time = time.time() - sitemap_start
+        print(f"{Fore.GREEN}done ({sitemap_time * 1000:.0f}ms){Style.RESET_ALL}")
+
+    print("> Finalizing build... ", end="", flush=True)
+    finalize_start = time.time()
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+    shutil.move(temp_build_dir, output_dir)
+    finalize_time = time.time() - finalize_start
+    print(f"{Fore.GREEN}done ({finalize_time * 1000:.0f}ms){Style.RESET_ALL}")
+
+    total_time = time.time() - start_time
+    print(f"{Fore.GREEN}Build complete in {total_time * 1000:.0f}ms!{Style.RESET_ALL}\n")
+
+
+def _process_site_files(config, template_env, md_processor, data, build_dir):
+    seen_outputs = {}
+    exclude_dirs = [cfg.get_templates_dir(config)]
+    blog_dir = cfg.get_blog_dir(config)
+    if blog_dir:
+        exclude_dirs.append(blog_dir)
+
+    site_dir = cfg.get_site_dir(config)
+    for root, dirs, files in os.walk(site_dir):
+        dirs[:] = [d for d in dirs if os.path.join(root, d) not in exclude_dirs]
+
+        for filename in files:
+            filepath = os.path.join(root, filename)
+
+            if any(filepath.startswith(excluded) for excluded in exclude_dirs):
+                continue
+            if filename.startswith("."):
+                continue
+
+            rel_path = os.path.relpath(filepath, site_dir)
+
+            if rel_path.endswith(".md"):
+                output_path = os.path.join(build_dir, rel_path[:-3] + ".html")
+            else:
+                output_path = os.path.join(build_dir, rel_path)
+
+            if output_path in seen_outputs:
+                warn(f"Duplicate output: {output_path} (from {filepath} and {seen_outputs[output_path]})")
+            seen_outputs[output_path] = filepath
+
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+            if filepath.endswith(".md"):
+                _process_markdown_file(config, template_env, md_processor, data, filepath, output_path, rel_path)
+            elif filepath.endswith(".html"):
+                _process_html_file(config, template_env, data, filepath, output_path, rel_path)
+            else:
+                shutil.copy2(filepath, output_path)
+
+
+def _process_markdown_file(config, template_env, md_processor, data, filepath, output_path, rel_path):
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    metadata, markdown_content = parse_front_matter(content)
+    html_content = md_processor.convert(markdown_content)
+    md_processor.reset()
+
+    template_name = metadata.get("template")
+    if not template_name:
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(html_content)
+        return
+
+    try:
+        active_page, canonical_path = infer_page_metadata(rel_path, cfg.get_base_path(config))
+
+        page_data = {"content": html_content}
+        page_data["metadata"] = metadata
+        if "active_page" not in page_data:
+            page_data["active_page"] = active_page
+        if "canonical_path" not in page_data:
+            page_data["canonical_path"] = canonical_path
+
+        template = template_env.get_template(template_name)
+        rendered = template.render(page=page_data, data=data)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(rendered)
+    except Exception as e:
+        warn(f"Failed to render {filepath}: {e}")
+
+
+def _process_html_file(config, template_env, data, filepath, output_path, rel_path):
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    metadata, html_content = parse_front_matter(content)
+
+    if metadata:
+        template_name = metadata.get("template", cfg.get_default_template(config))
+        try:
+            active_page, canonical_path = infer_page_metadata(rel_path, cfg.get_base_path(config))
+
+            page_data = {"content": html_content}
+            page_data["metadata"] = metadata
+            if "active_page" not in page_data:
+                page_data["active_page"] = active_page
+            if "canonical_path" not in page_data:
+                page_data["canonical_path"] = canonical_path
+
+            template = template_env.get_template(template_name)
+            rendered = template.render(page=page_data, data=data)
+        except Exception as e:
+            warn(f"Failed to render {filepath}: {e}")
+            return
+    else:
+        try:
+            active_page, canonical_path = infer_page_metadata(rel_path, cfg.get_base_path(config))
+            page_data = {
+                "active_page": active_page,
+                "canonical_path": canonical_path
+            }
+            template = template_env.from_string(content)
+            rendered = template.render(
+                page=page_data,
+                data=data,
+            )
+        except Exception as e:
+            warn(f"Failed to render {filepath}: {e}")
+            return
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(rendered)

stapler/core/utils.py

@@ -0,0 +1,83 @@
+import os
+import re
+import subprocess
+from datetime import datetime, timezone
+
+import yaml
+from colorama import Fore, Style
+
+
+FRONT_MATTER_PATTERN = re.compile(r"^---\n(.*?)\n---", re.DOTALL)
+
+
+def warn(message):
+    print(f"{Fore.YELLOW}WARNING: {message}{Style.RESET_ALL}")
+
+
+def parse_front_matter(content):
+    match = FRONT_MATTER_PATTERN.match(content)
+    if match:
+        metadata = yaml.safe_load(match.group(1)) or {}
+        remaining = content.split("---", 2)[2].strip()
+        return metadata, remaining
+    return {}, content
+
+
+def get_git_commit_info():
+    try:
+        output = subprocess.check_output(
+            ["git", "log", "-1", "--format=%h %H %ct"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+        if output:
+            parts = output.split()
+            if len(parts) == 3:
+                short_hash = parts[0]
+                long_hash = parts[1]
+                commit_ts = int(parts[2])
+                commit_dt = datetime.fromtimestamp(commit_ts, tz=timezone.utc)
+                return {
+                    "hash": {"short": short_hash, "long": long_hash},
+                    "dt": {
+                        "date": {
+                            "long": commit_dt.strftime("%B %d, %Y"),
+                            "short": commit_dt.strftime("%Y-%m-%d"),
+                        },
+                        "time": commit_dt.strftime("%H:%M:%S"),
+                        "iso": commit_dt.isoformat(),
+                    },
+                }
+    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+        pass
+    return None
+
+
+def get_data():
+    now = datetime.now(timezone.utc)
+    return {
+        "last_commit": get_git_commit_info(),
+        "now": {
+            "date": {
+                "long": now.strftime("%B %d, %Y"),
+                "short": now.strftime("%Y-%m-%d"),
+            },
+            "time": now.strftime("%H:%M:%S"),
+            "iso": now.isoformat(),
+        },
+    }
+
+
+def infer_page_metadata(rel_path, base_path=""):
+    if rel_path == "index.html":
+        canonical_path = base_path if base_path else "/"
+    else:
+        path_without_ext = os.path.splitext(rel_path)[0]
+        canonical_path = f"{base_path}/{path_without_ext}" if base_path else f"/{path_without_ext}"
+
+    active_page = rel_path.split("/")[0].replace(".html", "").replace(".md", "")
+
+    if active_page == "index":
+        active_page = "home"
+
+    return active_page, canonical_path

stapler/plugins/blog.py

@@ -0,0 +1,162 @@
+import os
+import subprocess
+from datetime import datetime, timezone
+
+from feedgen.feed import FeedGenerator
+
+from .. import config as cfg
+from ..core.utils import parse_front_matter, warn
+
+
+def process_blog(config, template_env, md_processor, data, build_dir):
+    posts = []
+    blog_slugs = set()
+
+    blog_dir = cfg.get_blog_dir(config)
+    if not os.path.exists(blog_dir):
+        return posts
+
+    for filename in os.listdir(blog_dir):
+        if not filename.endswith(".md"):
+            continue
+
+        slug = filename.replace(".md", "")
+        if slug in blog_slugs:
+            warn(f"Duplicate blog slug: {slug}")
+        blog_slugs.add(slug)
+
+        filepath = os.path.join(blog_dir, filename)
+        post = _process_post(config, md_processor, filepath, slug)
+        if post:
+            posts.append(post)
+
+    posts.sort(
+        key=lambda p: p.get("created") or datetime.min.replace(tzinfo=timezone.utc),
+        reverse=True,
+    )
+
+    blog_section = os.path.basename(blog_dir)
+    blog_build_dir = os.path.join(build_dir, blog_section)
+    os.makedirs(blog_build_dir, exist_ok=True)
+
+    _generate_blog_index(config, template_env, data, blog_build_dir, blog_section, posts)
+    _generate_post_pages(config, template_env, data, blog_build_dir, blog_section, posts)
+
+    if cfg.has_feeds(config):
+        _generate_feeds(config, blog_build_dir, blog_section, posts)
+
+    return posts
+
+
+def _process_post(config, md_processor, filepath, slug):
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    metadata, markdown_content = parse_front_matter(content)
+    html_content = md_processor.convert(markdown_content)
+    md_processor.reset()
+
+    date_str = metadata.get("date")
+    if date_str:
+        if isinstance(date_str, str):
+            created_date = datetime.strptime(date_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+        else:
+            created_date = datetime.combine(date_str, datetime.min.time()).replace(tzinfo=timezone.utc)
+    else:
+        created_date = _get_git_date(filepath)
+        if not created_date:
+            warn(f"No date found for blog post: {os.path.basename(filepath)}")
+
+    post = {
+        "title": metadata.get("title", slug.replace("-", " ").title()),
+        "slug": slug,
+        "content": html_content,
+        "filepath": filepath,
+        "created": created_date,
+    }
+
+    if created_date:
+        post["date"] = created_date.strftime("%Y-%m-%d")
+        post["date_iso"] = created_date.isoformat()
+
+    return post
+
+
+def _get_git_date(filepath):
+    try:
+        output = subprocess.check_output(
+            ["git", "log", "--follow", "--format=%H %ct", "--", filepath],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+        if output:
+            first_commit_ts = int(output.split("\n")[-1].split()[1])
+            return datetime.fromtimestamp(first_commit_ts, tz=timezone.utc)
+    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+        pass
+    return None
+
+
+def _generate_blog_index(config, template_env, data, blog_dir, blog_section, posts):
+    base_path = cfg.get_base_path(config)
+    canonical_path = f"{base_path}/{blog_section}" if base_path else f"/{blog_section}"
+
+    with open(os.path.join(blog_dir, "index.html"), "w", encoding="utf-8") as f:
+        f.write(
+            template_env.get_template(cfg.get_blog_index_template(config)).render(
+                posts=posts,
+                page={"active_page": blog_section, "canonical_path": canonical_path},
+                data=data,
+            )
+        )
+
+
+def _generate_post_pages(config, template_env, data, blog_dir, blog_section, posts):
+    base_path = cfg.get_base_path(config)
+    for post in posts:
+        canonical_path = f"{base_path}/{blog_section}/{post['slug']}" if base_path else f"/{blog_section}/{post['slug']}"
+
+        post_path = os.path.join(blog_dir, f"{post['slug']}.html")
+        with open(post_path, "w", encoding="utf-8") as f:
+            f.write(
+                template_env.get_template(cfg.get_blog_template(config)).render(
+                    post=post,
+                    page={"active_page": blog_section, "canonical_path": canonical_path},
+                    data=data,
+                )
+            )
+
+
+def _generate_feeds(config, blog_dir, blog_section, posts):
+    fg = FeedGenerator()
+    fg.title(f"{cfg.get_site_title(config)} - {blog_section}")
+    fg.description(cfg.get_site_description(config))
+    fg.id(cfg.get_site_url(config))
+    fg.link(href=f"{cfg.get_site_url(config)}/{blog_section}", rel="alternate")
+    fg.language("en")
+
+    author_name = cfg.get_author_name(config)
+    if author_name:
+        fg.author(
+            name=author_name,
+            email=cfg.get_author_email(config) or None,
+            uri=cfg.get_site_url(config),
+        )
+
+    for post in posts:
+        fe = fg.add_entry()
+        fe.title(post["title"])
+        fe.link(href=f"{cfg.get_site_url(config)}/{blog_section}/{post['slug']}")
+        fe.id(f"{cfg.get_site_url(config)}/{blog_section}/{post['slug']}")
+        fe.description(post["content"])
+        if post.get("created"):
+            fe.pubDate(post["created"])
+            fe.updated(post["created"])
+
+    formats = cfg.get_feed_formats(config)
+    if "rss" in formats:
+        with open(os.path.join(blog_dir, "rss.xml"), "wb") as f:
+            f.write(fg.rss_str(pretty=True))
+    if "atom" in formats:
+        with open(os.path.join(blog_dir, "atom.xml"), "wb") as f:
+            f.write(fg.atom_str(pretty=True))

stapler/plugins/sitemap.py

@@ -0,0 +1,55 @@
+import os
+import xml.etree.ElementTree as ET
+
+from .. import config as cfg
+
+
+def generate_sitemap(config, build_dir, posts):
+    urlset = ET.Element("urlset", xmlns="http://www.sitemaps.org/schemas/sitemap/0.9")
+
+    _add_url(urlset, f"{cfg.get_site_url(config)}/")
+
+    if cfg.has_blog(config) and posts:
+        blog_section = os.path.basename(cfg.get_blog_dir(config))
+        _add_url(urlset, f"{cfg.get_site_url(config)}/{blog_section}/")
+
+        for post in posts:
+            lastmod = post["created"].strftime("%Y-%m-%d") if post.get("created") else None
+            _add_url(
+                urlset,
+                f"{cfg.get_site_url(config)}/{blog_section}/{post['slug']}",
+                lastmod=lastmod,
+            )
+
+    for root, _, files in os.walk(build_dir):
+        for filename in files:
+            if not filename.endswith(".html"):
+                continue
+            if filename in ["404.html", "index.html"]:
+                continue
+
+            filepath = os.path.join(root, filename)
+            rel_path = os.path.relpath(filepath, build_dir)
+
+            if cfg.has_blog(config):
+                blog_section = os.path.basename(cfg.get_blog_dir(config))
+                if rel_path.startswith(blog_section):
+                    continue
+
+            url_path = "/" + rel_path.replace("\\", "/").replace(".html", "")
+            _add_url(urlset, f"{cfg.get_site_url(config)}{url_path}")
+
+    tree = ET.ElementTree(urlset)
+    ET.indent(tree, space="    ")
+    tree.write(
+        os.path.join(build_dir, "sitemap.xml"),
+        encoding="utf-8",
+        xml_declaration=True,
+    )
+
+
+def _add_url(urlset, loc, lastmod=None):
+    url = ET.SubElement(urlset, "url")
+    ET.SubElement(url, "loc").text = loc
+    if lastmod:
+        ET.SubElement(url, "lastmod").text = lastmod

stapler/server.py

@@ -0,0 +1,139 @@
+import os
+import sys
+import threading
+import time
+from datetime import datetime, timezone
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+
+from colorama import Fore, Style
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from . import config as cfg
+from .core.engine import build_site
+
+
+class BuildHandler(FileSystemEventHandler):
+    def __init__(self, build_func):
+        self.build_func = build_func
+        self.last_build = 0
+
+    def on_modified(self, event):
+        if event.is_directory or "build" in event.src_path:
+            return
+
+        now = time.time()
+        if now - self.last_build < 1:
+            return
+        self.last_build = now
+
+        if os.path.basename(event.src_path) in ["stapler.toml", "stapler.yaml", "stapler.yml"]:
+            print(f"\n{Fore.YELLOW}Config changed! Restarting...{Style.RESET_ALL}\n")
+            os.execv(sys.executable, [sys.executable] + sys.argv)
+
+        rel_path = os.path.relpath(event.src_path)
+        timestamp = datetime.now(timezone.utc).strftime("%H:%M:%S")
+        print(f"\n{Fore.BLUE}[{timestamp}]{Style.RESET_ALL} {Fore.YELLOW}File changed:{Style.RESET_ALL} {rel_path}\n")
+        self.build_func()
+
+
+class StaplerHTTPServer(SimpleHTTPRequestHandler):
+    directory = "build"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=self.directory, **kwargs)
+
+    def log_message(self, format, *args):
+        request_line = args[0]
+        parts = request_line.split()
+
+        if len(parts) >= 2:
+            method = parts[0]
+            path = parts[1]
+        else:
+            method = ""
+            path = request_line
+
+        method_colors = {
+            "GET": Fore.CYAN,
+            "POST": Fore.YELLOW,
+            "PUT": Fore.MAGENTA,
+            "DELETE": Fore.RED,
+        }
+        method_color = method_colors.get(method, Fore.WHITE)
+
+        status = args[1] if len(args) > 1 else "000"
+        if status.startswith("2"):
+            status_color = Fore.GREEN
+        elif status.startswith("3"):
+            status_color = Fore.CYAN
+        elif status.startswith("4"):
+            status_color = Fore.YELLOW
+        else:
+            status_color = Fore.RED
+
+        timestamp = datetime.now(timezone.utc).strftime("%H:%M:%S")
+        print(f"{Fore.BLUE}[{timestamp}]{Style.RESET_ALL}  {method_color}{Style.BRIGHT}{method}{Style.RESET_ALL}  {Fore.WHITE}{path}{Style.RESET_ALL}  {status_color}{status}{Style.RESET_ALL}")
+
+    def do_GET(self):
+        path = self.translate_path(self.path)
+
+        if self.path.endswith("/") or self.path == "":
+            index_path = os.path.join(path, "index.html")
+            if os.path.isfile(index_path):
+                self.path = self.path.rstrip("/") + "/index.html" if not self.path.endswith("index.html") else self.path
+                return super().do_GET()
+
+        if os.path.isfile(path):
+            return super().do_GET()
+
+        if not self.path.endswith("/") and "." not in os.path.basename(self.path):
+            html_path = path + ".html"
+            if os.path.isfile(html_path):
+                self.path += ".html"
+                return super().do_GET()
+
+        not_found_path = os.path.join(self.directory, "404.html")
+        if os.path.isfile(not_found_path):
+            self.send_response(404)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            with open(not_found_path, "rb") as f:
+                self.wfile.write(f.read())
+            return
+
+        self.send_error(404, "File not found")
+
+
+def serve(config, port=8000):
+    print(f"{Fore.BLUE}=== Development Server ==={Style.RESET_ALL}\n")
+
+    build_site(config, is_dev=True)
+
+    observer = Observer()
+    handler = BuildHandler(lambda: build_site(config, is_dev=True))
+    observer.schedule(handler, cfg.get_site_dir(config), recursive=True)
+    observer.schedule(handler, ".", recursive=False)
+    observer.start()
+
+    build_dev_dir = cfg.get_build_dev_dir(config)
+
+    class DevHTTPServer(StaplerHTTPServer):
+        directory = build_dev_dir
+
+    server = HTTPServer(("localhost", port), DevHTTPServer)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+
+    print(f"{Fore.GREEN}Server running at {Style.BRIGHT}http://localhost:{port}{Style.RESET_ALL}")
+    print(f"{Fore.CYAN}Serving from: {Style.BRIGHT}{build_dev_dir}/{Style.RESET_ALL}")
+    print(f"{Fore.MAGENTA}Watching: {Style.BRIGHT}{cfg.get_site_dir(config)}/ {Style.RESET_ALL}and config file")
+    print(f"\n{Fore.YELLOW}Press Ctrl+C to stop{Style.RESET_ALL}\n")
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print(f"\n{Fore.RED}Stopping server...{Style.RESET_ALL}")
+        observer.stop()
+        server.shutdown()
+        observer.join()

stapler_ssg-0.1.2.dist-info/METADATA

@@ -0,0 +1,284 @@
+Metadata-Version: 2.4
+Name: stapler-ssg
+Version: 0.1.2
+Summary: Simple Jinja-based static site generator
+Project-URL: Homepage, https://github.com/gijs6/stapler
+Project-URL: Repository, https://github.com/gijs6/stapler
+Author-email: Gijs6 <me@gijs6.nl>
+License: Unlicense
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: feedgen>=1.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: markdown>=3.5.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: watchdog>=3.0.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Stapler
+
+A simple static site generator built with Jinja and Markdown.
+
+## Installation
+
+Clone the repo:
+
+```bash
+git clone https://github.com/gijs6/stapler.git
+cd stapler
+```
+
+Create a virtual environment (recommended):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+Install:
+
+```bash
+pip install -e .
+```
+
+Or with dev dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+1. Create a `stapler.toml` in your project root:
+
+```toml
+[site]
+url = "https://yoursite.com"
+title = "Your site"
+```
+
+2. Put your content in a `site/` directory (the default). Templates go in `site/templates/`.
+
+3. Run:
+
+```bash
+stapler serve   # local dev server on port 8000
+stapler build   # production build
+```
+
+## Configuration
+
+### Required
+
+```toml
+[site]
+url = "https://yoursite.com"
+title = "Your site"
+```
+
+### Optional
+
+#### Site metadata
+
+```toml
+[site]
+description = "About your site"
+base_path = "/blog"                # Deploy to example.com/blog instead of the root
+```
+
+#### Author info
+
+Used in RSS/Atom feeds.
+
+```toml
+[site.author]
+name = "Your name"
+email = "you@example.com"
+```
+
+#### Directories
+
+All paths are relative to where you run `stapler`.
+
+```toml
+[directories]
+site = "site"                      # Content directory (default: "site")
+build = "build"                    # Production output (default: "build")
+build_dev = "build-dev"            # Dev server output (default: "build-dev")
+templates = "templates"            # Templates folder inside the site directory (default: "templates")
+blog = "blog"                      # Blog posts folder inside the site directory (default: "blog")
+```
+
+#### Default template
+
+The template used for HTML pages that have front matter but no `template` field.
+
+```toml
+[templates]
+default = "base.html"
+```
+
+#### Blog
+
+```toml
+[features.blog]
+enabled = true                     # Enable blog functionality (default: false)
+template = "blog_post.html"        # Template for individual posts
+index_template = "blog_index.html" # Template for the blog index page
+```
+
+#### Sitemap and feeds
+
+```toml
+[features]
+sitemap = true                     # Generate sitemap.xml (default: true)
+
+[features.feeds]
+rss = true                         # Generate rss.xml (default: true)
+atom = true                        # Generate atom.xml (default: true)
+```
+
+Feeds are only generated when the blog feature is enabled.
+
+#### Markdown extensions
+
+```toml
+[markdown]
+extensions = ["meta", "tables", "fenced_code"]  # Python-Markdown extensions
+```
+
+## How it works
+
+### Pages
+
+Any `.html` or `.md` file in your site directory (excluding the templates and blog folders) becomes a page.
+
+#### Markdown files
+
+Markdown files are always rendered to HTML. If the front matter includes a `template` field, the result is passed to that template as `page.content`. Without a `template` field (or without front matter entirely), the raw HTML is written directly.
+
+```markdown
+---
+template: base.html
+title: My page
+---
+
+# Content
+
+Regular markdown here
+```
+
+#### HTML files
+
+HTML files with front matter are rendered through a template. The `template` field in front matter takes precedence; if omitted, the default template from `[templates].default` is used.
+
+```html
+---
+title: My page
+---
+<h1>Content here</h1>
+```
+
+HTML files without front matter are treated as Jinja templates directly:
+
+```html
+{% extends "base.html" %}
+{% block content %}
+<h1>Hello</h1>
+{% endblock %}
+```
+
+Front matter is YAML. All fields are available as `page.metadata.<field>` in your templates.
+
+#### Static files
+
+Anything that's not a `.html` or `.md` file (and not in your templates or blog folder) is copied as-is to the output directory.
+
+### Blog
+
+Enable the blog feature in your config, then put `.md` files in your blog directory.
+
+```markdown
+---
+title: My post
+date: 2025-01-15
+---
+
+Post content here
+```
+
+The `date` field is optional. If omitted, stapler tries to infer it from the file's git history.
+
+### Templates
+
+Templates live in the directory you configured (default: `site/templates/`).
+
+#### Available in all templates
+
+- `data`: build info
+  - `data.now`: current build time
+    - `data.now.date.long`: date as `%B %d, %Y` (e.g. `April 12, 2026`)
+    - `data.now.date.short`: date as `%Y-%m-%d` (e.g. `2026-04-12`)
+    - `data.now.time`: time as `%H:%M:%S`
+    - `data.now.iso`: datetime as ISO 8601
+  - `data.last_commit`: last git commit info (`None` if not in a git repo)
+    - `data.last_commit.hash.short`: short 7-character commit hash
+    - `data.last_commit.hash.long`: full commit hash
+    - `data.last_commit.dt.date.long`: date as `%B %d, %Y` (e.g. `April 12, 2026`)
+    - `data.last_commit.dt.date.short`: date as `%Y-%m-%d` (e.g. `2026-04-12`)
+    - `data.last_commit.dt.time`: time as `%H:%M:%S`
+    - `data.last_commit.dt.iso`: datetime as ISO 8601
+
+#### Regular page templates
+
+- `page`: the current page
+  - `page.active_page`: identifier derived from the filename (e.g. `about` for `about.html`, `home` for `index.html`), useful for highlighting the active nav item
+  - `page.canonical_path`: URL path of the page (e.g. `/about`)
+  - `page.content`: page content as HTML (only present if the page has front matter)
+  - `page.metadata.<field>`: any front matter field (e.g. `page.metadata.title`)
+
+#### Blog post template
+
+- `page`: navigation info
+  - `page.active_page`: name of the blog directory (e.g. `blog`)
+  - `page.canonical_path`: URL path of the post (e.g. `/blog/my-post`)
+- `post`: the current blog post
+  - `post.title`: post title (from front matter, or derived from the filename)
+  - `post.slug`: URL slug (filename without `.md`)
+  - `post.content`: post content as HTML
+  - `post.date`: date as `%Y-%m-%d` (e.g. `2026-04-12`), only set if a date is available
+  - `post.date_iso`: date as ISO 8601, only set if a date is available
+- `data`: same as above
+
+#### Blog index template
+
+- `page`: navigation info
+  - `page.active_page`: name of the blog directory (e.g. `blog`)
+  - `page.canonical_path`: URL path of the blog index (e.g. `/blog`)
+- `posts`: list of all blog posts sorted newest first; each item has the same fields as `post` above
+- `data`: same as above
+
+## CLI
+
+```bash
+# Build with default config (stapler.toml)
+stapler build
+
+# Build with custom config
+stapler build -c myconfig.toml
+
+# Serve on default port (8000)
+stapler serve
+
+# Serve on custom port
+stapler serve -p 3000
+
+# Serve with custom config and port
+stapler serve -c myconfig.toml -p 3000
+
+# Show version
+stapler --version
+```

stapler_ssg-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+stapler/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+stapler/cli.py,sha256=kML5JdfwhedTtOIT95eJvednRxlWZXU6ydKYmLXlVNU,1490
+stapler/config.py,sha256=bJ-3ot_F6f4dxL9T3lo10kc8OCJD7JHNI98V-Z0fuyU,3338
+stapler/server.py,sha256=079BaTG4QyIuRNkU3X3pafoQorkh_YggUILqf4KpvL0,4848
+stapler/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stapler/core/engine.py,sha256=LLLPydOf4xQ4amoXSRI8jtj9U8z5cTOe9tLdV0aWPF0,6993
+stapler/core/utils.py,sha256=hwx3ioPfN2nAI0PzIylvKAFZIqTG_NZ07nLgpquC-rU,2485
+stapler/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stapler/plugins/blog.py,sha256=UvIkGuyTlWQ-ML0zZI6gB_iiyUwFP03UMoAeUprKddI,5550
+stapler/plugins/sitemap.py,sha256=i5YOIpxi756W3clMc7z2uQPbIMBGO4NsEwY0_Pnjhz0,1808
+stapler_ssg-0.1.2.dist-info/METADATA,sha256=_6bNImOQXOa6zeoP3e2Sr27Oi7XqS2iKWXPtBR7sRkA,7094
+stapler_ssg-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+stapler_ssg-0.1.2.dist-info/entry_points.txt,sha256=TsUoOHKvki6YXJpsMcCQwoTrhwMu7bWYv874FCKRgrY,45
+stapler_ssg-0.1.2.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+stapler_ssg-0.1.2.dist-info/RECORD,,

stapler_ssg-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

stapler_ssg-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stapler = stapler.cli:main

stapler_ssg-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>