lotek 0.2.0__py3-none-any.whl

lotek/__init__.py

@@ -0,0 +1,13 @@
+"""lotek.run - A static site builder."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("lotek-run")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+import lotek.cli as cli
+
+def main():
+    cli.main()

lotek/build.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""lotek.run -- static site builder
+
+Requires: pandoc in PATH or markdown module
+"""
+
+from lotek.lib.site_config import config
+from lotek.lib.site_time import now_string
+from lotek.lib.pages import generate_pages
+from lotek.lib.posts import generate_posts, load_posts
+from lotek.lib.index import generate_index_landing
+from lotek.lib.dirs import dirs
+from lotek.lib.static import wipe_and_copy_to_output_dir
+from lotek.plugins.rss import generate_rss
+from lotek.plugins.robots import generate_robots
+
+
+def build():
+    """main entry point"""
+
+    out = dirs.OUTPUT
+    print(f"building lotek at {out}")
+    out.mkdir(exist_ok=True)
+    dirs.OUTPUT_POSTS.mkdir(exist_ok=True)
+    dirs.OUTPUT_STATIC.mkdir(exist_ok=True)
+    posts = load_posts(dirs.CONTENT_POSTS)
+
+    generate_posts(posts, out)
+    generate_pages(out)
+    if config.features.robotstxt:
+        print("generating robots.txt...")
+        generate_robots(posts, out)
+    if config.features.rss:
+        print("generating RSS feed...")
+        generate_rss(posts, out)
+    generate_index_landing(posts, out)
+    wipe_and_copy_to_output_dir(out)
+
+    print(f"built {len(posts)} posts -> output/")
+    last_file = out / "_last"
+    last_file.write_text(now_string())

lotek/cli.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""lotek - operational command for lotek.run."""
+import sys
+import argparse
+from pathlib import Path
+import lotek
+
+from lotek.lib.init import init
+from lotek.cmd.add import cmd_add
+from lotek.cmd.build import cmd_build
+from lotek.cmd.clean import cmd_clean
+from lotek.cmd.deploy import cmd_deploy
+from lotek.cmd.list import cmd_list
+from lotek.cmd.publish import cmd_publish, cmd_unpublish
+from lotek.cmd.serve import cmd_serve
+
+USAGE = f"""
+lotek - Tiny Blog Management Tool
+ver: {getattr(lotek, "__version__", "unknown")}
+
+Build:
+  lotek build             Build the site
+  lotek clean             Remove build output
+  lotek serve [--port N]  Serve output locally (default: 8000)
+  lotek deploy            Build and deploy via rsync (reads .env)
+
+Content:
+  lotek init              Make a new site from scratch
+  lotek list              List all posts
+  lotek add <title>       Create new post
+  lotek publish <slug>    Mark a post as published
+  lotek unpublish <slug>  Mark a post as unpublished
+"""
+
+def setup_cmd_parser():
+    parser = argparse.ArgumentParser(prog="lotek")
+    subs = parser.add_subparsers(dest="command")
+
+    i = subs.add_parser("init")
+    i.add_argument("path", type=str, default=".", nargs="?")
+
+    subs.add_parser("build")
+
+    subs.add_parser("clean")
+
+    p = subs.add_parser("serve")
+    p.add_argument("--port", "-p", type=int, default=8000)
+
+    p = subs.add_parser("deploy")
+    p.add_argument("--skip-build", action="store_true")
+
+
+    subs.add_parser("list")
+
+    p = subs.add_parser("add")
+    p.add_argument("title", nargs="?")
+
+    p = subs.add_parser("publish")
+    p.add_argument("slug")
+
+    p = subs.add_parser("unpublish")
+    p.add_argument("slug")
+
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = setup_cmd_parser()
+    if not args.command:
+        print(USAGE)
+        return 0
+    try:
+        if args.command == "init":
+            return init(Path.absolute(Path(args.path)))
+        if args.command == "build":
+            return cmd_build()
+        if args.command == "clean":
+            return cmd_clean()
+        if args.command == "serve":
+            return cmd_serve(args.port)
+        if args.command == "deploy":
+            return cmd_deploy(skip_build=args.skip_build)
+        if args.command == "list":
+            return cmd_list()
+        if args.command == "add":
+            return cmd_add(args.title)
+        if args.command == "publish":
+            return cmd_publish(args.slug)
+        if args.command == "unpublish":
+            return cmd_unpublish(args.slug)
+    except KeyboardInterrupt:
+        print("\nInterrupted")
+        return 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+if __name__ == "__main__":
+    main()

lotek/cmd/add.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from lotek.lib.colors import red, green
+from lotek.lib.dirs import dirs
+
+def cmd_add(title):
+    if not title:
+        print(red("Title required"))
+        return 1
+    posts_dir = dirs.CONTENT_POSTS
+    posts_dir.mkdir(parents=True, exist_ok=True)
+    today = datetime.now().strftime("%Y-%m-%d")
+    slug = title.lower().replace(" ", "-")
+    fname = f"{today}-{slug}.md"
+    fp = posts_dir / fname
+    if fp.exists():
+        print(red(f"Already exists: {fname}"))
+        return 1
+    template_path = dirs.TEMPLATES / "post.md"
+    if not template_path.exists():
+        print(red("Templates not found — run 'lotek init' first"))
+        return 1
+    template = template_path.read_text()
+    fp.write_text(template.replace("{title}", title).replace("{date}", today))
+    print(green(f"Created: content/posts/{fname}"))
+    return 0

lotek/cmd/build.py

@@ -0,0 +1,12 @@
+import sys
+from lotek.lib.colors import red
+import lotek.build as build_module
+
+def cmd_build():
+
+    try:
+        build_module.build()
+        return 0
+    except Exception as e:
+        print(red(f"Build failed: {e}"), file=sys.stderr)
+        return 1

lotek/cmd/clean.py

@@ -0,0 +1,12 @@
+
+import shutil
+from lotek.lib.colors import green
+from lotek.lib.dirs import dirs
+
+def cmd_clean():
+
+    output = dirs.OUTPUT
+    if output.exists():
+        shutil.rmtree(output)
+        print(green("Removed output/"))
+    return 0

lotek/cmd/deploy.py

@@ -0,0 +1,52 @@
+import subprocess
+
+from lotek.lib.colors import green, red
+from lotek.lib.dirs import dirs
+from lotek.cmd.build import cmd_build
+
+def read_env():
+    env_path = dirs.CWD / ".env"
+    if not env_path.exists():
+        return {}
+    env = {}
+    for line in env_path.read_text().splitlines():
+        if "=" in line and not line.startswith("#"):
+            k, _, v = line.partition("=")
+            env[k.strip()] = v.strip()
+    return env
+
+
+def cmd_deploy(skip_build=False):
+    env = read_env()
+    user, host, path = (
+        env.get("DEPLOY_USER"),
+        env.get("DEPLOY_HOST"),
+        env.get("DEPLOY_PATH"),
+    )
+    if not all([user, host, path]):
+        print(red("Missing DEPLOY_USER, DEPLOY_HOST, or DEPLOY_PATH in .env"))
+        return 1
+    if not skip_build:
+        print(green("Building..."))
+        rc = cmd_build()
+        if rc != 0:
+            return rc
+    dest = f"{user}@{host}:{path}/"
+    print(green(f"Deploying to {dest}"))
+    result = subprocess.run(
+        [
+            "rsync",
+            "-avz",
+            "--exclude=.env",
+            "--exclude=*.pyc",
+            "--exclude=__pycache__",
+            "--exclude=output",
+            "output/",
+            dest,
+        ]
+    )
+    if result.returncode != 0:
+        print(red("Deploy failed"))
+        return result.returncode
+    print(green("Deployed successfully"))
+    return 0

lotek/cmd/list.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+
+from lotek.lib.site_config import config
+from lotek.lib.dirs import dirs
+from lotek.lib.frontmatter import parse_frontmatter
+from lotek.lib.colors import green, BOLD, RESET
+
+def _table(headers, rows):
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, c in enumerate(row):
+            widths[i] = max(widths[i], len(str(c)))
+    hdr = "│ " + " │ ".join(h.center(w) for h, w in zip(headers, widths)) + " │"
+    print(BOLD + hdr + RESET)
+    print("-" * len(hdr))
+    for row in rows:
+        print("│ " + " │ ".join(str(c).ljust(w) for c, w in zip(row, widths)) + " │")
+
+def cmd_list():
+    posts_dir = dirs.CONTENT_POSTS
+    if not posts_dir.exists():
+        print("No posts directory found")
+        return 0
+    today = datetime.now().date()
+    posts = []
+    for f in posts_dir.glob("*.md"):
+        meta, _ = parse_frontmatter(f.read_text())
+        if meta.get("title"):
+            posts.append((f, meta))
+    if not posts:
+        print("No posts found")
+        return 0
+
+    def sort_key(item):
+        try:
+            return datetime.strptime(item[1].get("date", ""), "%Y-%m-%d").date()
+        except ValueError:
+            return today
+
+    posts.sort(key=sort_key, reverse=True)
+    rows = []
+    for f, meta in posts:
+        date_str = meta.get("date", "")
+        if meta.get("publish", "").lower() == "false":
+            state = "hidden"
+        elif config.features.skip_future:
+            try:
+                d = datetime.strptime(date_str, "%Y-%m-%d").date()
+                state = f"in {(d - today).days}d" if d > today else "live"
+            except ValueError:
+                state = "live"
+        else:
+            state = "live"
+        rows.append([date_str, meta.get("title", ""), f.stem, state])
+    print(green(f"{len(posts)} post(s)"))
+    _table(["date", "title", "slug", "status"], rows)
+    return 0

lotek/cmd/publish.py

@@ -0,0 +1,63 @@
+import sys
+
+from lotek.lib.frontmatter import parse_frontmatter
+from lotek.lib.colors import green, red
+from lotek.lib.dirs import dirs
+
+def _strip_datecode(stem):
+    if (
+        len(stem) > 11
+        and stem.startswith("20")
+        and stem[4] == stem[7] == "-"
+        and stem[10] == "-"
+    ):
+        return stem[11:]
+    return stem
+
+def find_post(slug):
+    posts_dir = dirs.CONTENT_POSTS
+    if not posts_dir.exists():
+        return None
+    fp = posts_dir / f"{slug}.md"
+    if fp.exists():
+        return fp
+    for f in posts_dir.glob("*.md"):
+        if slug == _strip_datecode(f.stem):
+            return f
+    matches = [
+        f for f in posts_dir.glob("*.md") if _strip_datecode(f.stem).startswith(slug)
+    ]
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        print(red(f"Ambiguous: {len(matches)} matches for '{slug}'"))
+        for m in matches:
+            print(f"  {m.stem}")
+        sys.exit(2)
+    return None
+
+def _set_publish(slug, value):
+    fp = find_post(slug)
+    if not fp:
+        print(red(f"Not found: {slug}"))
+        return 1
+    meta, body = parse_frontmatter(fp.read_text())
+    if not meta.get("title"):
+        print(red("No title in frontmatter"))
+        return 1
+    meta["publish"] = value
+    fp.write_text(
+        "---\n" + "".join(f"{k}: {v}\n" for k, v in meta.items()) + "---\n\n" + body
+    )
+    print(green(f"{'Published' if value == 'true' else 'Unpublished'}: {slug}"))
+    return 0
+
+
+def cmd_publish(slug):
+    """ i don't know if we even need these, really."""
+    return _set_publish(slug, "true")
+
+
+def cmd_unpublish(slug):
+    """ i don't know if we even need these, really."""
+    return _set_publish(slug, "false")

lotek/cmd/serve.py

@@ -0,0 +1,18 @@
+import subprocess
+import sys
+from lotek.lib.colors import green, red
+from lotek.lib.dirs import dirs
+
+def cmd_serve(port=8000):
+    output = dirs.OUTPUT
+    if not output.exists():
+        print(red("No output/ — run 'lotek build' first."))
+        return 1
+    print(green(f"Serving at http://localhost:{port}  (Ctrl-C to stop)"))
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "http.server", str(port), "-d", str(output)]
+        )
+    except KeyboardInterrupt:
+        pass
+    return 0

lotek/lib/__init__.py

@@ -0,0 +1 @@
+"""Core library modules for lotek.run."""

lotek/lib/about.py

@@ -0,0 +1,28 @@
+"""generate the about page"""
+
+from lotek.lib.site_config import config
+from lotek.lib.dirs import dirs
+from lotek.lib.render import render, render_wrap, md_to_html
+from lotek.lib.frontmatter import parse_frontmatter
+
+
+def generate_about(out):
+    about = dirs.CONTENT_PAGES / "about.md"
+    if about.exists():
+        meta, body = parse_frontmatter(about.read_text())
+        html = md_to_html(body)
+        content = render(
+            "post.html",
+            {
+                "TITLE": meta.get("title", "About"),
+                "DATE": "",
+                "CONTENT": html,
+            },
+        )
+        (out / "about.html").write_text(
+            render_wrap(
+                content,
+                f"About - {config.site.title}",
+                url=f"{config.site.url}/about.html",
+            )
+        )

lotek/lib/colors.py

@@ -0,0 +1,18 @@
+import os
+import sys
+
+BOLD, RESET = "\033[1m", "\033[0m"
+
+def _color(t, c):
+    if os.isatty(sys.stderr.fileno()):
+        return c + t + RESET
+    return t
+
+def green(t):
+    return _color(t, "\033[32m")
+
+def red(t):
+    return _color(t, "\033[31m")
+
+def dim(t):
+    return _color(t, "\033[2m")

lotek/lib/dirs.py

@@ -0,0 +1,26 @@
+"""lotek directory structure"""
+from pathlib import Path
+
+class Dirs:
+    """lotek directory structure"""
+    def __init__(self, path=Path.cwd()):
+        # pylint: disable=invalid-name
+        self.CWD = path
+        self.CONTENT = self.CWD / "content"
+        self.CONTENT_POSTS = self.CONTENT / "posts"
+        self.CONTENT_PAGES = self.CONTENT / "pages"
+
+        self.STATIC = self.CWD / "static"
+        self.IMAGES = self.CWD / "static" / "img"
+        self.TEMPLATES = self.CWD / "templates"
+
+        self.OUTPUT = self.CWD / "output"
+        self.OUTPUT_POSTS = self.CWD / "output" / "posts"
+        self.OUTPUT_STATIC = self.CWD / "output" / "static"
+
+        # expected to be buried somewhere in site-packages
+        self.PKG = _pkg_path = Path(__file__).parent.parent
+        self.PKG_TEMPLATES = self.PKG / "templates"
+        self.PKG_STATIC = self.PKG / "static"
+
+dirs = Dirs()

lotek/lib/frontmatter.py

@@ -0,0 +1,17 @@
+"""frontmatter parsing for markdown files"""
+
+
+def parse_frontmatter(text):
+    """parse the frontmatter from a markdown file, returning a dict of metadata and the body text"""
+    if not text.startswith("---\n"):
+        return {}, text
+    try:
+        end = text.index("\n---\n", 4)
+    except ValueError:
+        return {}, text
+    meta = {}
+    for line in text[4:end].splitlines():
+        if ":" in line:
+            k, _, v = line.partition(":")
+            meta[k.strip()] = v.strip()
+    return meta, text[end + 5 :]

lotek/lib/highlight.py

@@ -0,0 +1,25 @@
+"""Syntax highlighting via Pygments."""
+
+import re
+from pygments import highlight
+from pygments.formatters import HtmlFormatter
+from pygments.lexers import get_lexer_by_name
+from pygments.util import ClassNotFound
+
+_FENCE = re.compile(r"^```(\w*)\n([\s\S]*?)^```[ \t]*$", re.MULTILINE)
+_formatter = HtmlFormatter(style="default")
+
+
+def process_code_blocks(text):
+    def replace(m):
+        lang = m.group(1).strip().lower() or "text"
+        code = m.group(2)
+        if code.endswith("\n"):
+            code = code[:-1]
+        try:
+            lexer = get_lexer_by_name(lang, stripall=False)
+        except ClassNotFound:
+            lexer = get_lexer_by_name("text")
+        return "\n\n" + highlight(code, lexer, _formatter) + "\n\n"
+
+    return _FENCE.sub(replace, text)

lotek/lib/html_stubs.py

@@ -0,0 +1,23 @@
+"""HTML stubs for rendering templates."""
+
+from lotek.lib.site_config import config
+
+
+def html_stub_index(post):
+    """Generate the HTML for a single post in the index page."""
+    return f"""
+    <li><span class="date">{post["date"]}</span>
+        <a href="posts/{post["slug"]}.html">{post["title"]}</a>
+    </li>\n
+"""
+
+
+def html_stub_feed_items(post, html):
+    """Generate the HTML for a single post in the feed."""
+    return f"""
+    <item>
+      <title>{post['title']}</title>
+      <link>{config.site.url}/posts/{post['slug']}.html</link>
+      <pubDate>{post['date']}</pubDate>
+      <description><![CDATA[{html}]]></description>
+    </item>\n"""

lotek/lib/index.py

@@ -0,0 +1,20 @@
+"""index page generator"""
+
+from lotek.lib.site_config import config
+from lotek.lib.site_time import now_string
+from lotek.lib.html_stubs import html_stub_index
+from lotek.lib.render import render, render_wrap
+
+
+def generate_index_landing(posts, out):
+    """Generate the index landing page."""
+    items = ""
+    for post in posts:
+        items += html_stub_index(post)
+    content = render("index.html", {"ITEMS": items, "DESC": config.site.description})
+    (out / "index.html").write_text(
+        render_wrap(content, config.site.title, url=config.site.url)
+    )
+
+    last_file = out / "_last"
+    last_file.write_text(now_string())

lotek/lib/init.py

@@ -0,0 +1,107 @@
+"""Site initialization command for lotek.run."""
+
+import shutil
+from datetime import date
+from pathlib import Path
+from lotek.lib.site_config import DEFAULT_CONFIG_TEMPLATE_PATH
+from lotek.lib.dirs import Dirs
+
+# Get the package root directory
+_pkg_path = Path(__file__).parent.parent
+
+
+def init(site_path: Path) -> None:
+    """Initialize a new lotek site in the given directory.
+
+    Creates the directory structure, copies templates, and generates site-config.toml.
+
+    Args:
+        site_path: Path to the site directory to initialize. Uses cwd if not provided.
+    """
+    print(f"working path is: {site_path}")
+
+    dirs: Dirs = Dirs(site_path)
+    # Create directory structure
+    site_path.mkdir(parents=True, exist_ok=True)
+    dirs.CONTENT.mkdir(exist_ok=True)
+    dirs.CONTENT_POSTS.mkdir(parents=True, exist_ok=True)
+    dirs.CONTENT_PAGES.mkdir(exist_ok=True)
+    dirs.STATIC.mkdir(exist_ok=True)
+    dirs.IMAGES.mkdir(parents=True, exist_ok=True)
+    dirs.TEMPLATES.mkdir(exist_ok=True)
+    # Copy templates
+    print("Copying templates...")
+    for template in dirs.PKG_TEMPLATES.glob("*"):
+        dst = dirs.TEMPLATES / template.name
+        shutil.copy2(template, dst)
+
+    # Copy static files
+    print("Populating static directory..")
+    static_src = dirs.PKG_STATIC
+    for item in static_src.iterdir():
+        if item.is_dir():
+            shutil.copytree(item, dirs.STATIC / item.name, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, dirs.STATIC)
+
+    # Create site-config.toml from defaults
+    config_path = site_path / "site-config.toml"
+    if not config_path.exists():
+        print(f"Creating {config_path} from template...")
+        config_path.write_text(DEFAULT_CONFIG_TEMPLATE_PATH.read_text())
+        print("✓ Site configuration created")
+
+    # Create an about page
+    about_path = dirs.CONTENT_PAGES / "about.md"
+    if not about_path.exists():
+        print(f"Creating {about_path} from template...")
+        example_about = """---
+title: About
+date: 2026-06-15
+---
+
+lotek is a small static blog generator.  It uses very little technology to do this.
+
+The name comes from the Lo-Tek in William Gibson's Johnny Mnemonic -- an underground community that lives in the margins of the city, outside the corporate system. Not against technology. Against the assumption that more technology is always better, that the newest version is always correct, that you should replace what works because something newer exists.
+
+---
+
+**rss**: /feed.xml
+
+---
+
+Built with pandoc and a Python script. No npm. No framework. No build chain.
+"""
+        about_path.write_text(example_about)
+        print("✓ About page created")
+
+    # Create an example post
+    today = date.today().strftime("%Y-%m-%d")
+    example_post = dirs.CONTENT_POSTS / f"{today}-welcome.md"
+    if not example_post.exists():
+        example_content = f"""---
+title: Welcome to Lotek
+date: {today}
+desc: Your first post
+---
+
+Congratulations! You've created a new lotek site.
+
+This is your first post. Edit or delete this file to get started.
+
+## Quick Start
+
+1. Add more posts in `content/posts/`
+2. Add static pages in `content/pages/`
+3. Customize `site-config.toml` to change site settings
+4. Run `lotek build` to generate the site
+5. Serve it with `lotek serve`
+"""
+        example_post.write_text(example_content)
+        print("✓ Example post created")
+
+    print(f"\nSite initialized at: {dirs.CWD}")
+    print("Next steps:")
+    print("  - Edit content in content/posts/ and content/pages/")
+    print("  - Customize settings in site-config.toml")
+    print("  - Run 'lotek build' to generate the site")