418 lines
17 KiB
Python
418 lines
17 KiB
Python
# /// script
|
|
# requires-python = ">=3.12"
|
|
# dependencies = ["copier>=9.10", "questionary>=2.1"]
|
|
# ///
|
|
import argparse
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import questionary
|
|
from copier import run_copy, run_update
|
|
|
|
PUBLISHED = "https://git.kotikot.com/templates"
|
|
SOURCE = os.environ.get("TEMPLATES_DIR", PUBLISHED)
|
|
REF = os.environ.get("TEMPLATES_REF")
|
|
BLANK = "blank"
|
|
BACKENDS = {"python": "backend-python", "other": BLANK}
|
|
FRONTENDS = {"svelte": "frontend-svelte", "other": BLANK}
|
|
SERVE = ["bun", "static", "api"]
|
|
MCP = ["context7", "svelte"]
|
|
|
|
|
|
def template(name: str) -> str:
|
|
local = Path(SOURCE) / name
|
|
return str(local) if local.is_dir() else f"{SOURCE}/{name}.git"
|
|
|
|
|
|
def publish_answers(dest: Path) -> None:
|
|
"""Answers rendered from local checkouts (TEMPLATES_DIR) point at Gitea.
|
|
|
|
copier writes the path it rendered from into `_src_path`; a local path
|
|
only exists on this machine, and `updateproject` anywhere else fails.
|
|
"""
|
|
local = Path(SOURCE)
|
|
if not local.is_dir():
|
|
return
|
|
for answers in (dest / ".copier").glob("*.yml"):
|
|
lines = answers.read_text(encoding="utf-8").splitlines(keepends=True)
|
|
for i, line in enumerate(lines):
|
|
if not line.startswith("_src_path:"):
|
|
continue
|
|
src = Path(line.split(":", 1)[1].strip().strip("'\""))
|
|
if src.is_dir() and src.resolve().parent == local.resolve():
|
|
lines[i] = f"_src_path: {PUBLISHED}/{src.name}.git\n"
|
|
answers.write_text("".join(lines), encoding="utf-8")
|
|
|
|
|
|
def git_config(key: str) -> str:
|
|
result = subprocess.run(["git", "config", key], capture_output=True, text=True, check=False)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def interactive() -> bool:
|
|
return sys.stdin.isatty()
|
|
|
|
|
|
def ask_text(prompt: str, default: str) -> str:
|
|
return questionary.text(prompt, default=default).unsafe_ask() if interactive() else default
|
|
|
|
|
|
def ask_select(prompt: str, choices: list[str], default: str) -> str:
|
|
if not interactive():
|
|
return default
|
|
return questionary.select(prompt, choices=choices, default=default).unsafe_ask()
|
|
|
|
|
|
def ask_checkbox(prompt: str, choices: list[str], default: list[str]) -> list[str]:
|
|
if not interactive():
|
|
return default
|
|
items = [questionary.Choice(c, checked=c in default) for c in choices]
|
|
return questionary.checkbox(prompt, choices=items).unsafe_ask()
|
|
|
|
|
|
def slugify(name: str) -> str:
|
|
return re.sub(r"[^a-z0-9]", "_", name.lower())
|
|
|
|
|
|
def new(args: argparse.Namespace) -> None:
|
|
dest = Path(args.dest).resolve()
|
|
name = args.name or ask_text("Project name", dest.name)
|
|
slug = args.slug or ask_text("Slug", slugify(name))
|
|
description = args.description if args.description is not None else ask_text("Description", name)
|
|
parts = args.parts.split(",") if args.parts else ask_checkbox("Parts", ["backend", "frontend", "caddy"], ["backend", "frontend", "caddy"])
|
|
backend = frontend = None
|
|
if "backend" in parts:
|
|
backend = args.backend or ask_select("Backend", list(BACKENDS), "python")
|
|
if "frontend" in parts:
|
|
frontend = args.frontend or ask_select("Frontend", list(FRONTENDS), "svelte")
|
|
serve = "bun"
|
|
if frontend and FRONTENDS[frontend] != BLANK:
|
|
options = SERVE if backend else SERVE[:-1]
|
|
serve = args.serve or ask_select("Frontend served by", options, "bun")
|
|
mcp_default = ["svelte"] if frontend and FRONTENDS[frontend] == "frontend-svelte" else []
|
|
mcp = args.mcp.split(",") if args.mcp is not None else ask_checkbox("MCP servers", MCP, mcp_default)
|
|
mcp = [m for m in mcp if m]
|
|
stack = [p for p in ("backend", "frontend") if p in parts]
|
|
single = len(stack) == 1
|
|
routes = [r for r, ok in (("api", backend), ("frontend", frontend and serve != "api")) if ok]
|
|
|
|
def copy(name: str, data: dict, answers_file: str | None = None) -> None:
|
|
run_copy(template(name), dest, data=data, answers_file=answers_file, unsafe=True,
|
|
defaults=args.defaults, vcs_ref=REF)
|
|
|
|
def copy_part(part: str, name: str, data: dict) -> None:
|
|
if name == BLANK:
|
|
copy(name, {**identity, "layout": layout, "part": part}, f".copier/{part}.yml")
|
|
else:
|
|
copy(name, {**identity, "layout": layout, **data})
|
|
|
|
dest.mkdir(parents=True, exist_ok=True)
|
|
identity = {"project_name": name, "project_slug": slug}
|
|
copy("infra", {"project_name": name, "project_description": description, "layout": "single" if single else "parts",
|
|
"parts": [] if single else stack, "mcp_servers": mcp})
|
|
layout = "root" if single else "part"
|
|
if backend:
|
|
copy_part("backend", BACKENDS[backend], {"project_description": description, "serve_spa": serve == "api",
|
|
"author_name": git_config("user.name"),
|
|
"author_email": git_config("user.email")})
|
|
if frontend:
|
|
copy_part("frontend", FRONTENDS[frontend], {"serve": serve})
|
|
if "caddy" in parts:
|
|
copy("caddy", {"project_slug": slug, "routes": routes})
|
|
publish_answers(dest)
|
|
if (dest / "Makefile").is_file():
|
|
subprocess.run(["make", "env"], cwd=dest, check=True)
|
|
if args.repo or (args.repo is None and interactive()):
|
|
call = gitea_api()
|
|
repo = choose_repo(dest, args.repo, call)
|
|
if repo:
|
|
setup_repo(dest, repo, call)
|
|
|
|
|
|
def git_dirty() -> bool:
|
|
result = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True, check=False)
|
|
return bool(result.stdout.strip())
|
|
|
|
|
|
def update_message(answers: Path) -> str:
|
|
"""Conventional commit for a template update, with the version it moved to."""
|
|
ref = ""
|
|
for line in answers.read_text(encoding="utf-8").splitlines():
|
|
if line.startswith("_commit:"):
|
|
ref = line.split(":", 1)[1].strip().strip("'\"")
|
|
break
|
|
scope = answers.stem
|
|
return f"chore({scope}): update template to {ref}" if ref else f"chore({scope}): update template"
|
|
|
|
|
|
def refresh_locks(part: str) -> None:
|
|
root = Path(part) if Path(part, "Makefile").is_file() else Path()
|
|
if (root / "uv.lock").is_file():
|
|
subprocess.run(["uv", "lock", "-q"], cwd=root, check=True)
|
|
if (root / "bun.lock").is_file():
|
|
subprocess.run(["bun", "install", "--silent"], cwd=root, check=True)
|
|
|
|
|
|
def update(args: argparse.Namespace) -> None:
|
|
answers = sorted(Path(".copier").glob("*.yml"))
|
|
if args.parts:
|
|
answers = [Path(".copier") / f"{p}.yml" for p in args.parts]
|
|
if not answers:
|
|
sys.exit("no .copier/*.yml here")
|
|
if git_dirty():
|
|
sys.exit("working tree is dirty, commit or stash first")
|
|
for file in answers:
|
|
run_update(".", answers_file=str(file), unsafe=True, overwrite=True,
|
|
skip_answered=not args.ask, defaults=args.defaults, vcs_ref=REF)
|
|
conflicts = subprocess.run(["git", "diff", "--name-only", "--diff-filter=U"],
|
|
capture_output=True, text=True, check=False).stdout.split()
|
|
if conflicts:
|
|
sys.exit(f"{file.stem}: resolve conflicts, then commit and rerun:\n " + "\n ".join(conflicts))
|
|
refresh_locks(file.stem)
|
|
if git_dirty():
|
|
subprocess.run(["git", "add", "-A"], check=True)
|
|
subprocess.run(["git", "commit", "-qm", update_message(file)], check=True)
|
|
print(f"committed {file.stem} update")
|
|
|
|
|
|
CONFIG_FILE = Path.home() / ".config/templates/config.toml"
|
|
|
|
|
|
def config() -> dict:
|
|
import tomllib
|
|
|
|
return tomllib.loads(CONFIG_FILE.read_text(encoding="utf-8")) if CONFIG_FILE.is_file() else {}
|
|
|
|
|
|
GITEA = os.environ.get("GITEA_URL", config().get("gitea_url", "https://git.kotikot.com")).rstrip("/")
|
|
RENOVATE_FILE = "renovate.jsonc"
|
|
RENOVATE_STUB = """{
|
|
"$schema": "https://docs.renovatebot.com/renovate-schema.json",
|
|
"extends": ["local>templates/renovate"]
|
|
}
|
|
"""
|
|
RENOVATE_LABELS = [
|
|
("renovate", "1f6feb", "Pull request from the Renovate bot"),
|
|
("wait-3d", "d29922", "Waits three days: the registry has no release timestamp, the age gate merges it"),
|
|
("deps-code", "7d8590", "Code dependencies: pull requests are collected, nothing merges itself"),
|
|
]
|
|
|
|
|
|
def gitea_token() -> str:
|
|
token = os.environ.get("GITEA_TOKEN", "")
|
|
if token:
|
|
return token
|
|
path = Path.home() / ".config/gitea/token"
|
|
if path.exists():
|
|
return path.read_text(encoding="utf-8").strip()
|
|
sys.exit("no Gitea token: set GITEA_TOKEN or write ~/.config/gitea/token")
|
|
|
|
|
|
def gitea_api():
|
|
import json
|
|
import urllib.request
|
|
|
|
token = gitea_token()
|
|
|
|
def call(method: str, path: str, body: dict | None = None):
|
|
request = urllib.request.Request(
|
|
f"{GITEA}/api/v1{path}",
|
|
data=json.dumps(body).encode() if body is not None else None,
|
|
method=method,
|
|
headers={"Authorization": f"token {token}", "Content-Type": "application/json"},
|
|
)
|
|
with urllib.request.urlopen(request, timeout=30) as response:
|
|
raw = response.read()
|
|
return json.loads(raw) if raw else None
|
|
|
|
return call
|
|
|
|
|
|
def git(*args: str, cwd: Path) -> str:
|
|
result = subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True, check=False)
|
|
return result.stdout.strip() if result.returncode == 0 else ""
|
|
|
|
|
|
def project_description(cwd: Path) -> str:
|
|
answers = cwd / ".copier/infra.yml"
|
|
if not answers.is_file():
|
|
return ""
|
|
for line in answers.read_text(encoding="utf-8").splitlines():
|
|
if line.startswith("project_description:"):
|
|
return line.split(":", 1)[1].strip().strip("'\"")
|
|
return ""
|
|
|
|
|
|
def adopt(cwd: Path, branch: str) -> None:
|
|
"""Put a freshly rendered project on top of an existing repo.
|
|
|
|
The repo's history becomes the local one; what the templates rendered
|
|
stays in the working tree as uncommitted changes against it, files the
|
|
templates do not know are restored as they are in the repo.
|
|
"""
|
|
subprocess.run(["git", "fetch", "-q", "origin"], cwd=cwd, check=True)
|
|
# No commits yet: the branch is unborn, reset creates it at the repo's tip
|
|
# and keeps the working tree.
|
|
subprocess.run(["git", "symbolic-ref", "HEAD", f"refs/heads/{branch}"], cwd=cwd, check=True)
|
|
subprocess.run(["git", "reset", "-q", f"origin/{branch}"], cwd=cwd, check=True)
|
|
subprocess.run(["git", "branch", "-q", "-u", f"origin/{branch}"], cwd=cwd, check=True)
|
|
deleted = git("ls-files", "--deleted", cwd=cwd).splitlines()
|
|
if deleted:
|
|
subprocess.run(["git", "checkout", "-q", "--", *deleted], cwd=cwd, check=True)
|
|
print(
|
|
f"on {branch} of the existing repo: the rendered files are uncommitted changes on top of it.\n"
|
|
"Review with git status / git diff, keep what is yours (git checkout -- <file>), commit the rest."
|
|
)
|
|
|
|
|
|
def choose_repo(cwd: Path, repo: str | None, call) -> str | None:
|
|
if repo:
|
|
return repo
|
|
orgs = sorted(o["username"] for o in call("GET", "/user/orgs?limit=100") or [])
|
|
default = config().get("org") or (cwd.parent.name if cwd.parent.name in orgs else None)
|
|
if not interactive():
|
|
return f"{default}/{cwd.name}" if default else None
|
|
skip = "(no repo)"
|
|
org = questionary.select("Gitea organization", choices=[skip, *orgs], default=default or skip).unsafe_ask()
|
|
if org == skip:
|
|
return None
|
|
return f"{org}/{ask_text('Repo name', cwd.name)}"
|
|
|
|
|
|
def setup_repo(cwd: Path, repo: str, call) -> None:
|
|
import base64
|
|
import urllib.error
|
|
|
|
org, name = repo.split("/", 1)
|
|
try:
|
|
info = call("GET", f"/repos/{repo}")
|
|
print(f"repo {repo}: already there")
|
|
except urllib.error.HTTPError as error:
|
|
if error.code != 404:
|
|
sys.exit(f"repo {repo}: {error.code} {error.read()[:200]!r}")
|
|
info = call("POST", f"/orgs/{org}/repos", {
|
|
"name": name,
|
|
"description": project_description(cwd),
|
|
"private": config().get("private", True),
|
|
"default_branch": "main",
|
|
})
|
|
print(f"repo {repo}: created")
|
|
|
|
url = info["clone_url"] if config().get("remote") == "https" else info["ssh_url"]
|
|
if not info.get("empty", True) and not git("rev-parse", "--git-dir", cwd=cwd):
|
|
subprocess.run(["git", "init", "-q"], cwd=cwd, check=True)
|
|
if git("rev-parse", "--git-dir", cwd=cwd):
|
|
current = git("remote", "get-url", "origin", cwd=cwd)
|
|
if not current:
|
|
git("remote", "add", "origin", url, cwd=cwd)
|
|
print(f"origin: {url}")
|
|
elif current != url:
|
|
print(f"origin stays {current}, the repo is {url}")
|
|
if info.get("empty", True) and git("rev-parse", "--verify", "-q", "HEAD", cwd=cwd):
|
|
if not git("rev-parse", "--verify", "-q", "refs/heads/main", cwd=cwd):
|
|
git("branch", "-M", "main", cwd=cwd)
|
|
if not git("rev-parse", "--verify", "-q", "refs/heads/dev", cwd=cwd):
|
|
git("branch", "dev", "main", cwd=cwd)
|
|
subprocess.run(["git", "push", "-q", "-u", "origin", "main", "dev"], cwd=cwd, check=True)
|
|
git("switch", "-q", "dev", cwd=cwd)
|
|
print("pushed main and dev, on dev now")
|
|
elif info.get("empty", True):
|
|
print("nothing committed yet: commit, then run giteaproject again to push main and dev")
|
|
elif not git("rev-parse", "--verify", "-q", "HEAD", cwd=cwd):
|
|
adopt(cwd, info["default_branch"])
|
|
else:
|
|
print(f"{repo} is not empty and there are local commits: nothing pushed, merge them by hand")
|
|
|
|
existing = {label["name"] for label in call("GET", f"/repos/{repo}/labels?limit=100") or []}
|
|
for label, color, description in RENOVATE_LABELS:
|
|
if label in existing:
|
|
continue
|
|
call("POST", f"/repos/{repo}/labels", {"name": label, "color": color, "description": description})
|
|
print(f"label {label}: created")
|
|
|
|
remote_empty = call("GET", f"/repos/{repo}").get("empty", True)
|
|
if not remote_empty and not (cwd / RENOVATE_FILE).is_file():
|
|
try:
|
|
call("GET", f"/repos/{repo}/contents/{RENOVATE_FILE}")
|
|
except urllib.error.HTTPError as error:
|
|
if error.code != 404:
|
|
sys.exit(f"{RENOVATE_FILE}: {error.code} {error.read()[:200]!r}")
|
|
call("POST", f"/repos/{repo}/contents/{RENOVATE_FILE}", {
|
|
"content": base64.b64encode(RENOVATE_STUB.encode()).decode(),
|
|
"message": "chore(renovate): extend the shared preset",
|
|
})
|
|
print(f"{RENOVATE_FILE}: committed on the server, pull it")
|
|
|
|
teams = call("GET", f"/orgs/{org}/teams?limit=50") or []
|
|
team = next((t for t in teams if t["name"] == "renovate"), None)
|
|
if team is None:
|
|
team = call("POST", f"/orgs/{org}/teams", {
|
|
"name": "renovate",
|
|
"description": "Renovate bot: write on listed repos only, not the whole org",
|
|
"includes_all_repositories": False,
|
|
"permission": "none",
|
|
"units": ["repo.code", "repo.issues", "repo.pulls"],
|
|
"units_map": {"repo.code": "write", "repo.issues": "write", "repo.pulls": "write"},
|
|
"can_create_org_repo": False,
|
|
})
|
|
print(f"team renovate in {org}: created")
|
|
members = {m["login"] for m in call("GET", f"/teams/{team['id']}/members?limit=50") or []}
|
|
if "renovate" not in members:
|
|
call("PUT", f"/teams/{team['id']}/members/renovate")
|
|
print("bot renovate: added to the team")
|
|
repos = {r["name"] for r in call("GET", f"/teams/{team['id']}/repos?limit=50") or []}
|
|
if name not in repos:
|
|
call("PUT", f"/teams/{team['id']}/repos/{org}/{name}")
|
|
print(f"team renovate: access to {name}")
|
|
|
|
print(
|
|
f"\nStill manual: add {repo} to `repositories` in\n"
|
|
"projects/personal/renovate/renovate-config.js of infra/komodo,\n"
|
|
"the bot only visits repos named in that list."
|
|
)
|
|
|
|
|
|
def gitea(args: argparse.Namespace) -> None:
|
|
"""Create the Gitea repo if needed, point origin at it and prepare it for Renovate."""
|
|
cwd = Path.cwd()
|
|
call = gitea_api()
|
|
repo = choose_repo(cwd, args.repo, call)
|
|
if repo is None:
|
|
sys.exit("no repo chosen")
|
|
setup_repo(cwd, repo, call)
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(prog="templates")
|
|
sub = parser.add_subparsers(dest="command", required=True)
|
|
n = sub.add_parser("new", help="Compose a project from templates")
|
|
n.add_argument("dest")
|
|
n.add_argument("--name")
|
|
n.add_argument("--slug")
|
|
n.add_argument("--description")
|
|
n.add_argument("--parts", help="comma-separated: backend,frontend,caddy")
|
|
n.add_argument("--backend", choices=list(BACKENDS))
|
|
n.add_argument("--frontend", choices=list(FRONTENDS))
|
|
n.add_argument("--serve", choices=SERVE)
|
|
n.add_argument("--mcp", help="comma-separated: context7,svelte; empty for none")
|
|
n.add_argument("--repo", help="org/name on Gitea to create and use as origin; empty for none")
|
|
n.add_argument("--defaults", action="store_true", help="accept template defaults without asking")
|
|
n.set_defaults(func=new)
|
|
u = sub.add_parser("update", help="Update every part from its template")
|
|
u.add_argument("parts", nargs="*", help="parts to update, default all")
|
|
u.add_argument("--ask", action="store_true", help="ask every question again")
|
|
u.add_argument("--defaults", action="store_true")
|
|
u.set_defaults(func=update)
|
|
g = sub.add_parser("gitea", help="Create the Gitea repo, set origin, prepare it for Renovate")
|
|
g.add_argument("repo", nargs="?", help="org/name on Gitea, asked when omitted")
|
|
g.set_defaults(func=gitea)
|
|
args = parser.parse_args()
|
|
args.func(args)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|