docs(readme): renovate finds the repo itself, the repositories list is gone

.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
 .idea
+__pycache__/

README.md

@@ -1,43 +1,12 @@
 # newproject
 
-Composes a project from the templates in this organization: `infra` at the root, then `backend-python`, `frontend-svelte`, `blank` and `caddy` on top, each with its own answers file in `.copier/`.
+Builds a project from the templates: `infra` at the root, then `backend-python`, `frontend-svelte`, `blank` and `caddy`, each with its answers in `.copier/`.
 
 ```sh
 source ~/projects/templates/newproject/shell.sh
-newproject ~/projects/my-thing
+newproject ~/projects/my-thing      # asks; --parts, --backend, --frontend, --serve, --mcp, --repo, --defaults
-updateproject            # every part
+updateproject [part]                # clean tree, one commit per part
-updateproject backend    # one part
+giteaproject [org/name]             # repo in Gitea, origin, Renovate labels
 ```
 
-`newproject` asks for the description, the parts, the backend language, the frontend framework, how the frontend is served and the MCP servers for `.mcp.json`, then hands over to each template's own questions. Every prompt has a flag for non-interactive use:
+Templates come from Gitea (latest tag); `TEMPLATES_DIR` renders local checkouts, `TEMPLATES_REF=HEAD` their working trees. Renovate finds the repo on its own once `giteaproject` has put `renovate.jsonc` in it and the bot's team on it.
-
-```sh
-newproject ~/projects/my-thing --parts backend,frontend,caddy --backend python --frontend svelte --serve bun --mcp context7,svelte --defaults
-```
-
-`other` as the backend or the frontend renders the `blank` template: the part's compose files, Makefile and `.env.example` with no code, for a stack that has no template of its own, next to any other part.
-
-One part alone is rendered at the root of the project; two parts live in `backend/` and `frontend/`. After rendering, `make env` creates `.env` and every `docker-compose.override.yml` from their examples. `updateproject` needs a clean working tree and commits each part's update separately, so the next part starts from a clean tree again; conflicts stay in those commits for you to resolve. Templates are cloned from `https://git.kotikot.com/templates` unless `TEMPLATES_DIR` points at a directory with local checkouts; `TEMPLATES_REF=HEAD` renders their working trees instead of the latest tag.
-
-## Renovate
-
-A new repo needs the `renovate`, `wait-3d` and `deps-code` labels before the bot
-ever runs against it: Renovate fails on a label that does not exist, and until
-today these were created by hand for every repo.
-
-```sh
-giteaproject ms-agents/my-thing
-```
-
-It creates the labels and, if the repo has no `renovate.jsonc` yet, commits one
-that is nothing but an `extends` on the shared preset in `templates/renovate`.
-Projects rendered by `newproject` already carry that file from the `infra`
-template, so for them the command only does the labels.
-
-**Extending the preset does not subscribe the repo to anything.** The bot walks
-an explicit list, so the repo also has to be added to `repositories` in
-`projects/personal/renovate/renovate-config.js` of `infra/komodo`, and the
-`renovate` team of its organization needs write access to it. Miss that step and
-the config sits there doing nothing, silently.
-
-Requires `uv`; `bun`, `docker` and `pre-commit` are used by the generated projects.

templates.py

@@ -12,7 +12,8 @@ from pathlib import Path
 import questionary
 from copier import run_copy, run_update
 
-SOURCE = os.environ.get("TEMPLATES_DIR", "https://git.kotikot.com/templates")
+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}
@@ -26,6 +27,26 @@ def template(name: str) -> str:
     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()
@@ -101,8 +122,14 @@ def new(args: argparse.Namespace) -> None:
         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:
@@ -140,6 +167,10 @@ def update(args: argparse.Namespace) -> None:
     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)
@@ -147,7 +178,16 @@ def update(args: argparse.Namespace) -> None:
             print(f"committed {file.stem} update")
 
 
-GITEA = os.environ.get("GITEA_URL", "https://git.kotikot.com").rstrip("/")
+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",
@@ -171,11 +211,8 @@ def gitea_token() -> str:
     sys.exit("no Gitea token: set GITEA_TOKEN or write ~/.config/gitea/token")
 
 
-def gitea(args: argparse.Namespace) -> None:
+def gitea_api():
-    """Prepare a Gitea repo for Renovate: labels and the preset stub."""
-    import base64
     import json
-    import urllib.error
     import urllib.request
 
     token = gitea_token()
@@ -191,30 +228,124 @@ def gitea(args: argparse.Namespace) -> None:
             raw = response.read()
             return json.loads(raw) if raw else None
 
-    # Gitea happily creates a second label with the same name, so the only way to
+    return call
-    # stay idempotent is to look first.
-    existing = {label["name"] for label in call("GET", f"/repos/{args.repo}/labels?limit=100") or []}
-    for name, color, description in RENOVATE_LABELS:
-        if name in existing:
-            print(f"label {name}: already there")
-            continue
-        call("POST", f"/repos/{args.repo}/labels",
-             {"name": name, "color": color, "description": description})
-        print(f"label {name}: created")
 
+
+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:
-        call("GET", f"/repos/{args.repo}/contents/{RENOVATE_FILE}")
+        info = call("GET", f"/repos/{repo}")
-        print(f"{RENOVATE_FILE}: already there")
+        print(f"repo {repo}: already there")
     except urllib.error.HTTPError as error:
         if error.code != 404:
-            sys.exit(f"{RENOVATE_FILE}: {error.code} {error.read()[:200]!r}")
+            sys.exit(f"repo {repo}: {error.code} {error.read()[:200]!r}")
-        call("POST", f"/repos/{args.repo}/contents/{RENOVATE_FILE}", {
+        info = call("POST", f"/orgs/{org}/repos", {
-            "content": base64.b64encode(RENOVATE_STUB.encode()).decode(),
+            "name": name,
-            "message": "chore(renovate): extend the shared preset",
+            "description": project_description(cwd),
+            "private": config().get("private", True),
+            "default_branch": "main",
         })
-        print(f"{RENOVATE_FILE}: created")
+        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")
 
-    org, name = args.repo.split("/", 1)
     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:
@@ -228,27 +359,32 @@ def gitea(args: argparse.Namespace) -> None:
             "can_create_org_repo": False,
         })
         print(f"team renovate in {org}: created")
-        call("PUT", f"/teams/{team['id']}/members/renovate")
-        print("bot renovate: added to the team")
     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 in repos:
+    if name not in repos:
-        print(f"team access to {name}: already there")
-    else:
         call("PUT", f"/teams/{team['id']}/repos/{org}/{name}")
-        print(f"team access to {name}: granted")
+        print(f"team renovate: access to {name}")
 
     print(
-        "\nOne thing is still manual, and it does not happen by itself: the repo has\n"
+        f"\nStill manual: add {repo} to `repositories` in\n"
-        "to be added to `repositories` in projects/personal/renovate/renovate-config.js\n"
+        "projects/personal/renovate/renovate-config.js of infra/komodo,\n"
-        "of infra/komodo. Extending the preset subscribes nothing - the bot only visits\n"
+        "the bot only visits repos named in that list."
-        "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)
@@ -262,6 +398,7 @@ def main() -> None:
     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")
@@ -269,8 +406,8 @@ def main() -> None:
     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="Set a repo up for Renovate: labels and preset stub")
+    g = sub.add_parser("gitea", help="Create the Gitea repo, set origin, prepare it for Renovate")
-    g.add_argument("repo", help="org/name on Gitea")
+    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)