#!/usr/bin/env python3 """Pi extension repo workflow.""" from __future__ import annotations import argparse import importlib.util import json import os import re import shutil import subprocess import sys import tempfile import time from pathlib import Path from types import ModuleType ROOT = Path(__file__).resolve().parents[1] EXT_ROOT = ROOT / "extensions" DRIVER_ROOT = ROOT / "drivers" PI_PEERS = { "@earendil-works/pi-ai", "@earendil-works/pi-agent-core", "@earendil-works/pi-coding-agent", "@earendil-works/pi-tui", "typebox", } HARNESS = "@marcfargas/pi-test-harness" IMPORT_RE = re.compile( r"(?:import|export)\s+(?:[^'\"]+?\s+from\s+)?['\"]([^'\"]+)['\"]|import\(['\"]([^'\"]+)['\"]\)" ) SECRET_RE = re.compile(r"(api[_-]?key|secret|token|password)\s*[:=]\s*['\"][^'\"]{12,}", re.I) OSC_RE = re.compile(r"\x1b\][^\x07]*(?:\x07|\x1b\\)") ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]") CHANGELOG_STYLE = """Voice: - terse, technical, human - brutal minimalism: no marketing, no excitement, no filler - concrete nouns/verbs; name actual commands, tools, hooks, files, API - no corporate adjectives: enhanced, improved, streamlined, robust, seamless - also ban: powerful, comprehensive, leverage - no vague "various fixes" - write like a maintainer note, not an ad - short fragments beat full sentences Hard format: ## {version} - bullet - bullet Hard limits: - 3-5 bullets total - max 100 chars per bullet; rewrite until every bullet fits - each bullet must start with a verb, command name, or concrete noun - combine details; do not enumerate implementation internals separately - omit internal function names unless they are the change users maintain """ README_STYLE = """Return the full root README.md content for bugabinga/pi-ext. Use only the context in this prompt. Do not edit files. Do not say done. Do not summarize. Output the complete markdown file only. Task: - If root README.md exists: update it; preserve useful manual text; refresh stale facts. - If root README.md is missing: create it. Voice: - terse, technical, human - no marketing slime - funny is allowed; cute and mean is allowed; bloat is not - concrete install commands and examples Required content. For missing README, use these sections. For existing README, keep equivalent existing headings/placement when present: # pi-ext one-line description ## Install Use exact Pi CLI syntax. The command is `pi install`, never `pi ext install`. - all extensions via git: `pi install git:github.com/bugabinga/pi-ext@v{version}` - default branch install: `pi install git:github.com/bugabinga/pi-ext` - local checkout via absolute path: `pi install /home/me/Workspace/pi-ext` - local checkout via ~ path: `pi install ~/Workspace/pi-ext` - single-extension package filter JSON for `~/.pi/agent/settings.json` - explain skills/prompts/themes filters briefly ## Extensions Markdown table: extension slug, short explanation, link to sub README. One row per extension under extensions/*. ## Resources Mention skills/, prompts/, themes/ are exported by root Pi package manifest. ## Release model Single repo version. Tag format vX.Y.Z. Per-extension package versions intentionally absent. --- A cute, mean, dark haiku about these extensions and Pi philosophy. """ EXT_README_STYLE = """Return the full README.md content for one bugabinga/pi-ext extension. Use only the context in this prompt. Do not edit files. Do not say done. Do not summarize. Output the complete markdown file only. Task: - If README.md exists: update it; preserve useful manual text; refresh stale facts. - If README.md is missing: create it. - Preserve existing demo blocks exactly when present: ... . - Do not invent commands, tools, settings, env vars, or install paths. Voice: - terse, technical, human - no marketing slime - concrete behavior over adjectives Required content. For missing README, use these sections. For existing README, keep equivalent existing headings/placement when present: # extension-slug one-line purpose ## Install / load Briefly say this extension is loaded through the root pi-ext package. Link root README relatively as ../../README.md. ## Commands / tools / settings List actual commands/tools/hooks/settings. Say none where none exist. ## Behavior Short operational notes from source. ## Demo Only include when an existing demo block is provided in current README. """ def root_pkg() -> dict: return json.loads((ROOT / "package.json").read_text()) def root_version() -> str: return root_pkg().get("version", "0.0.0") def pkg_name(spec: str) -> str: if spec.startswith("@"): parts = spec.split("/") return "/".join(parts[:2]) return spec.split("/")[0] def read_pkg(ext: Path) -> dict: return json.loads((ext / "package.json").read_text()) def ext_dirs(selected: list[str]) -> list[Path]: dirs = sorted(p.parent for p in EXT_ROOT.glob("*/package.json")) if not selected: return dirs wanted = set(selected) result = [] for ext in dirs: pkg = read_pkg(ext) if ext.name in wanted or pkg.get("name") in wanted: result.append(ext) found = {ext.name for ext in result} | {read_pkg(ext).get("name") for ext in result} missing = wanted - found if missing: raise SystemExit(f"unknown extension(s): {', '.join(sorted(missing))}") return result def ts_files(ext: Path) -> list[Path]: return sorted(p for p in ext.rglob("*.ts") if "node_modules" not in p.parts) def import_specs(ext: Path) -> set[str]: specs: set[str] = set() for file in ts_files(ext): for match in IMPORT_RE.finditer(file.read_text(errors="ignore")): spec = match.group(1) or match.group(2) if spec: specs.add(spec) return specs def err(errors: list[str], ext: Path, msg: str) -> None: errors.append(f"{ext.name}: {msg}") def static_check(ext: Path) -> list[str]: errors: list[str] = [] try: pkg = read_pkg(ext) except Exception as e: return [f"{ext.name}: invalid package.json: {e}"] expected = f"@bugabinga/pi-ext-{ext.name}" if pkg.get("name") != expected: err(errors, ext, f"package name must be {expected!r}") if pkg.get("version") is not None: err( errors, ext, "per-extension version must be absent; root package.json owns repo version" ) if pkg.get("private") is not True: err(errors, ext, "package must have private:true") if pkg.get("type") != "module": err(errors, ext, "package.json type must be 'module'") if pkg.get("main") != "index.ts": err(errors, ext, "package.json main must be 'index.ts'") if not (ext / "index.ts").exists(): err(errors, ext, "missing index.ts") if pkg.get("license") != "MIT": err(errors, ext, "package license must be MIT") if not (ext / "README.md").exists(): err(errors, ext, "missing README.md") deps = pkg.get("dependencies", {}) or {} peers = pkg.get("peerDependencies", {}) or {} dev = pkg.get("devDependencies", {}) or {} scripts = pkg.get("scripts", {}) or {} if dev.get(HARNESS) is None: err(errors, ext, f"missing devDependency {HARNESS}") if scripts.get("test:harness") != "bun test ./__tests__/harness.test.ts": err(errors, ext, "missing script test:harness='bun test ./__tests__/harness.test.ts'") if not (ext / "__tests__" / "harness.test.ts").exists(): err(errors, ext, "missing __tests__/harness.test.ts") for dep in deps: if dep in PI_PEERS: err(errors, ext, f"Pi package {dep} belongs in peerDependencies, not dependencies") if dep.startswith("@bugabinga/pi-ext-"): err(errors, ext, f"must not depend on sibling extension {dep}") for dep in peers: if dep.startswith("@bugabinga/pi-ext-"): err(errors, ext, f"must not peer-depend on sibling extension {dep}") specs = import_specs(ext) packages = { pkg_name(s) for s in specs if not ( s.startswith(".") or s.startswith("/") or s.startswith("node:") or s.startswith("bun:") ) } for spec in specs: if spec.startswith("@bugabinga/pi-ext-"): err(errors, ext, f"must not import sibling extension {spec}") for file in ts_files(ext): text = file.read_text(errors="ignore") for match in IMPORT_RE.finditer(text): spec = match.group(1) or match.group(2) if not spec or not spec.startswith("../"): continue resolved = (file.parent / spec).resolve() try: resolved.relative_to(ext.resolve()) except ValueError: err( errors, ext, f"cross-extension relative import {spec} in {file.relative_to(ext)}", ) if SECRET_RE.search(text): err(errors, ext, f"possible secret in {file.relative_to(ext)}") for dep in sorted(packages & PI_PEERS): if dep not in peers: err(errors, ext, f"imported {dep} but missing peerDependency") for dep in sorted(packages - PI_PEERS): if dep not in deps and dep not in peers and dep not in dev: err( errors, ext, f"imported external package {dep} but package.json does not declare it" ) return errors def external_deps(pkg: dict) -> list[str]: deps = set() for key in ("dependencies", "peerDependencies", "devDependencies"): deps.update((pkg.get(key) or {}).keys()) return sorted(deps) def install(ext: Path) -> None: subprocess.run(["bun", "install", "--silent"], cwd=ext, check=True) def build(ext: Path, out_root: Path) -> None: pkg = read_pkg(ext) cmd = ["bun", "build", "index.ts", "--target", "bun", "--outdir", str(out_root / ext.name)] for dep in external_deps(pkg): cmd.extend(["--external", dep]) subprocess.run(cmd, cwd=ext, check=True, capture_output=True, text=True) def run_tests(ext: Path) -> None: subprocess.run(["bun", "test"], cwd=ext, check=True, capture_output=True, text=True) def git(*args: str, check: bool = True, capture: bool = False) -> subprocess.CompletedProcess[str]: return subprocess.run( ["git", *args], cwd=ROOT, check=check, text=True, stdout=subprocess.PIPE if capture else None, stderr=subprocess.PIPE if capture else None, ) def jj(*args: str, check: bool = True, capture: bool = False) -> subprocess.CompletedProcess[str]: return subprocess.run( ["jj", *args], cwd=ROOT, check=check, text=True, stdout=subprocess.PIPE if capture else None, stderr=subprocess.PIPE if capture else None, ) def use_jj() -> bool: proc = jj("root", check=False, capture=True) return proc.returncode == 0 and Path(proc.stdout.strip()).resolve() == ROOT def git_changes(path: Path, since: str | None) -> list[str]: cmd = ["log", "--format=%h %s"] if since: cmd.append(f"{since}..HEAD") cmd.extend(["--", str(path.relative_to(ROOT))]) proc = git(*cmd, check=False, capture=True) if proc.returncode != 0: return [] return [line.strip() for line in proc.stdout.splitlines() if line.strip()] def latest_release_tag() -> str | None: proc = git("tag", "--list", "v*", "--sort=-creatordate", capture=True) tags = [line.strip() for line in proc.stdout.splitlines() if line.strip()] return tags[0] if tags else None def changed_since_release(path: Path) -> bool: rel = str(path.relative_to(ROOT)) if git("status", "--porcelain", "--", rel, capture=True).stdout.strip(): return True tag = latest_release_tag() if not tag: return True return git("diff", "--quiet", tag, "--", rel, check=False).returncode != 0 def any_changed_since_release(paths: list[Path]) -> bool: tag = latest_release_tag() if not tag: return True return any(changed_since_release(path) for path in paths) def strip_terminal_noise(text: str) -> str: return ANSI_RE.sub("", OSC_RE.sub("", text)).strip() def pi_generate(prompt: str, model: str | None = None, label: str = "agent") -> str: cmd = [ "pi", "--no-session", "--no-tools", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-context-files", "-p", ] if model: cmd.extend(["--model", model]) cmd.append(prompt) with ( tempfile.TemporaryFile("w+", encoding="utf-8") as out, tempfile.TemporaryFile("w+", encoding="utf-8") as err_out, ): proc = subprocess.Popen(cmd, cwd=ROOT, text=True, stdout=out, stderr=err_out) frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏" start = time.monotonic() i = 0 tty = sys.stderr.isatty() if not tty: print(f"RUN {label}", file=sys.stderr) while proc.poll() is None: elapsed = int(time.monotonic() - start) if tty: print( f"\r{frames[i % len(frames)]} {label} {elapsed}s", end="", file=sys.stderr, flush=True, ) i += 1 time.sleep(0.12) elapsed = int(time.monotonic() - start) out.seek(0) err_out.seek(0) stdout = out.read() stderr = err_out.read() if tty: icon = "✓" if proc.returncode == 0 else "✗" print(f"\r{icon} {label} {elapsed}s\033[K", file=sys.stderr, flush=True) else: print(("OK" if proc.returncode == 0 else "ERROR") + f" {label} {elapsed}s", file=sys.stderr) if proc.returncode != 0: if stderr: print(stderr, file=sys.stderr) raise subprocess.CalledProcessError(proc.returncode, proc.args, stdout, stderr) return strip_terminal_noise(stdout) def changelog_prompt(ext: Path) -> str: pkg = read_pkg(ext) version = root_version() tag = latest_release_tag() commits = git_changes(ext, tag) commit_text = "\n".join(f"- {line}" for line in commits) or "- no commits since previous tag" rel = ext.relative_to(ROOT) return f"""You are writing one changelog section for one Pi extension. Output markdown only. No preamble. No code fence. {CHANGELOG_STYLE.format(version=version)} Task: Extension: {ext.name} Package: {pkg["name"]} Path: {rel} Repo version: {version} Previous repo tag: {tag or "none"} Use only the context in this prompt. Do not edit files. Git commits touching this extension: {commit_text} """ def generate_changelog_entry(ext: Path, model: str | None = None) -> str: out = pi_generate(changelog_prompt(ext), model, f"changelog {ext.name}") if not out.startswith("## "): raise RuntimeError(f"bad changelog output for {ext.name}: {out[:200]!r}") return out.rstrip() + "\n" def update_changelog(ext: Path, model: str | None = None) -> str: path = ext / "CHANGELOG.md" entry = generate_changelog_entry(ext, model) heading = f"## {root_version()}" if not path.exists(): path.write_text(f"# Changelog\n\n{entry}") print(f"OK changelog {ext.name}") return entry text = path.read_text() if heading in text: lines = text.splitlines(keepends=True) start = next(i for i, line in enumerate(lines) if line.startswith(heading)) end = next( (i for i in range(start + 1, len(lines)) if lines[i].startswith("## ")), len(lines) ) path.write_text("".join(lines[:start]) + entry + "\n" + "".join(lines[end:]).lstrip("\n")) elif text.startswith("# Changelog"): _, rest = text.split("\n", 1) path.write_text("# Changelog\n\n" + entry + "\n" + rest.lstrip("\n")) else: path.write_text(f"# Changelog\n\n{entry}\n{text}") print(f"OK changelog {ext.name}") return entry def repo_changelog_prompt(exts: list[Path]) -> str: version = root_version() tag = latest_release_tag() commit_text = ( "\n".join(f"- {line}" for line in git_changes(ROOT, tag)) or "- no commits since previous tag" ) names = ", ".join(ext.name for ext in exts) return f"""Write one repo-level CHANGELOG.md section for bugabinga/pi-ext. Output markdown only. No preamble. No code fence. {CHANGELOG_STYLE.format(version=version)} Scope: {names} Repo version: {version} Previous repo tag: {tag or "none"} Use only the context in this prompt. Do not edit files. Summarize cross-extension release value, not every tiny file. Git commits: {commit_text} """ def generate_repo_changelog_entry(exts: list[Path], model: str | None = None) -> str: entry = pi_generate(repo_changelog_prompt(exts), model, "changelog root").rstrip() + "\n" if not entry.startswith("## "): raise RuntimeError(f"bad repo changelog output: {entry[:200]!r}") return entry def update_repo_changelog(exts: list[Path], model: str | None = None) -> str: entry = generate_repo_changelog_entry(exts, model) path = ROOT / "CHANGELOG.md" heading = f"## {root_version()}" if not path.exists(): path.write_text(f"# Changelog\n\n{entry}") print("OK changelog root") return entry text = path.read_text() if heading in text: lines = text.splitlines(keepends=True) start = next(i for i, line in enumerate(lines) if line.startswith(heading)) end = next( (i for i in range(start + 1, len(lines)) if lines[i].startswith("## ")), len(lines) ) path.write_text("".join(lines[:start]) + entry + "\n" + "".join(lines[end:]).lstrip("\n")) elif text.startswith("# Changelog"): _, rest = text.split("\n", 1) path.write_text("# Changelog\n\n" + entry + "\n" + rest.lstrip("\n")) else: path.write_text(f"# Changelog\n\n{entry}\n{text}") print("OK changelog root") return entry def readme_prompt() -> str: version = root_version() current = ( (ROOT / "README.md").read_text(errors="ignore") if (ROOT / "README.md").exists() else "" ) exts = [] for ext in ext_dirs([]): pkg = read_pkg(ext) readme = (ext / "README.md").read_text(errors="ignore")[:1200] exts.append(f"- {ext.name}: package={pkg['name']}\nREADME excerpt:\n{readme}") return f"""{README_STYLE.format(version=version)} Existing root README.md: {current or ""} Root package.json: {json.dumps(root_pkg(), indent=2)} Extensions: {chr(10).join(exts)} """ def first_heading_markdown(text: str) -> str: lines = text.splitlines() start = next((i for i, line in enumerate(lines) if line.startswith("# ")), -1) if start > 0: return "\n".join(lines[start:]).rstrip() + "\n" return text.rstrip() + "\n" def generate_readme(model: str | None = None) -> str: out = first_heading_markdown(pi_generate(readme_prompt(), model, "README root")) if not out.startswith("# pi-ext"): raise RuntimeError(f"bad README output: {out[:200]!r}") return out.rstrip() + "\n" def update_readme(model: str | None = None) -> str: text = generate_readme(model) (ROOT / "README.md").write_text(text) print("OK README.md") return text def ext_readme_prompt(ext: Path) -> str: pkg = read_pkg(ext) current = (ext / "README.md").read_text(errors="ignore") if (ext / "README.md").exists() else "" sources = [] for file in ts_files(ext)[:8]: rel = file.relative_to(ext) sources.append(f"--- {rel} ---\n{file.read_text(errors='ignore')[:5000]}") return f"""{EXT_README_STYLE} Extension: {ext.name} Package.json: {json.dumps(pkg, indent=2)} Existing README.md: {current or ""} Source excerpts: {chr(10).join(sources)} """ def generate_ext_readme(ext: Path, model: str | None = None) -> str: prompt = ext_readme_prompt(ext) label = f"README {ext.name}" last = "" for attempt in range(2): out = first_heading_markdown( pi_generate(prompt, model, label if attempt == 0 else f"{label} retry") ) last = out if out.startswith("# "): return out.rstrip() + "\n" prompt += f""" Previous output was invalid because it did not start with a markdown H1 heading (`# ...`). Retry. Output the complete README.md only. First bytes must be `# {ext.name}` or another H1. Invalid output prefix: {out[:500]} """ raise RuntimeError(f"bad README output for {ext.name}: {last[:200]!r}") def update_ext_readme(ext: Path, model: str | None = None) -> str: text = generate_ext_readme(ext, model) (ext / "README.md").write_text(text) print(f"OK README {ext.name}") return text def update_all_readmes(exts: list[Path], model: str | None = None) -> None: tag = latest_release_tag() errors: list[str] = [] if any_changed_since_release([ROOT / "README.md", ROOT / "package.json", EXT_ROOT]): try: update_readme(model) except Exception as e: errors.append(f"root: {e}") print(f"ERROR README root: {e}", file=sys.stderr) else: print(f"OK README root skipped (unchanged since {tag})") for ext in exts: if not changed_since_release(ext): print(f"OK README {ext.name} skipped (unchanged since {tag})") continue try: update_ext_readme(ext, model) except Exception as e: errors.append(f"{ext.name}: {e}") print(f"ERROR README {ext.name}: {e}", file=sys.stderr) if errors: raise SystemExit("README generation failed: " + "; ".join(errors)) def load_driver(path: Path) -> ModuleType: spec = importlib.util.spec_from_file_location(f"driver_{path.stem}", path) if spec is None or spec.loader is None: raise SystemExit(f"cannot load driver: {path}") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module def drivers_for(exts: list[Path]) -> list[tuple[str, list[str]]]: selected = {ext.name for ext in exts} drivers: list[tuple[str, list[str]]] = [] for path in sorted(DRIVER_ROOT.glob("*.py")): if path.name.startswith("__"): continue module = load_driver(path) targets = getattr(module, "targets", []) if isinstance(targets, list) and selected.intersection(targets): drivers.append((path.stem, [t for t in targets if isinstance(t, str)])) return drivers def demo_installed(driver: str, targets: list[str]) -> bool: for target in targets: ext = EXT_ROOT / target if not (ext / "README.md").exists() or not (ext / "assets" / f"{driver}.gif").exists(): return False return True def installed_drivers_for(exts: list[Path]) -> list[tuple[str, list[str]]]: return [ (driver, targets) for driver, targets in drivers_for(exts) if demo_installed(driver, targets) ] def demo_changed_since_release(driver: str, targets: list[str]) -> bool: module = load_driver(DRIVER_ROOT / f"{driver}.py") extensions = [name for name in getattr(module, "extensions", []) if isinstance(name, str)] paths = [DRIVER_ROOT / f"{driver}.py"] paths.extend(EXT_ROOT / name for name in sorted(set(targets + extensions))) return any_changed_since_release(paths) def demos_to_update(drivers: list[tuple[str, list[str]]]) -> list[tuple[str, list[str]]]: return [ (driver, targets) for driver, targets in drivers if demo_changed_since_release(driver, targets) ] def update_demo_drivers(drivers: list[tuple[str, list[str]]]) -> list[Path]: tag = latest_release_tag() selected = demos_to_update(drivers) skipped = sorted( set(driver for driver, _targets in drivers) - set(driver for driver, _targets in selected) ) for driver in skipped: print(f"OK demo {driver} skipped (unchanged since {tag})") if not selected: print("OK demo none") return [] touched: set[Path] = set() for driver, targets in selected: subprocess.run(["python3", "scripts/demo.py", driver], cwd=ROOT, check=True) touched.update(EXT_ROOT / target for target in targets) print(f"OK demo {driver}") return sorted(path for path in touched if path.exists()) def update_demos(exts: list[Path]) -> list[Path]: return update_demo_drivers(installed_drivers_for(exts)) def jj_commit_id(rev: str) -> str: return jj( "log", "-r", rev, "--no-graph", "--template", "commit_id", capture=True ).stdout.strip() def release_bookmark() -> str: names = jj("bookmark", "list", capture=True).stdout for name in ("trunk", "main", "master"): if re.search(rf"^{re.escape(name)}:", names, re.M): return name return "trunk" def changed_paths() -> list[Path]: if use_jj(): out = jj("diff", "--name-only", capture=True).stdout else: out = ( git("diff", "--name-only", capture=True).stdout + "\n" + git("diff", "--cached", "--name-only", capture=True).stdout ) return sorted({Path(line) for line in out.splitlines() if line.strip()}) def allowed_change(path: Path, roots: list[Path]) -> bool: for root in roots: rel = root.relative_to(ROOT) if path == rel or rel in path.parents: return True return False def assert_only_release_changes(paths_to_add: list[Path]) -> None: roots = [path for path in paths_to_add if path.exists()] extra = [path for path in changed_paths() if not allowed_change(path, roots)] if extra: raise SystemExit( "refusing to publish unrelated change(s): " + ", ".join(str(path) for path in extra) ) def create_tag() -> str: tag = f"v{root_version()}" exists = ( git("rev-parse", "--verify", "--quiet", f"refs/tags/{tag}", check=False).returncode == 0 ) if exists: print(f"OK tag {tag} exists") else: if use_jj(): jj("git", "export") target = jj_commit_id("@-") else: target = "HEAD" git("tag", tag, target) print(f"OK tag {tag}") return tag def commit_release(paths_to_add: list[Path]) -> None: assert_only_release_changes(paths_to_add) if use_jj(): if jj("diff", "--quiet", check=False).returncode == 0: print("OK commit none") return jj("commit", "-m", f"release: v{root_version()}") bookmark = release_bookmark() jj("bookmark", "set", bookmark, "-r", "@-") print(f"OK commit v{root_version()} ({bookmark})") return paths = sorted({str(path.relative_to(ROOT)) for path in paths_to_add if path.exists()}) git("add", *paths) if git("diff", "--cached", "--quiet", "--", *paths, check=False).returncode == 0: print("OK commit none") return git("commit", "-m", f"release: v{root_version()}", "--", *paths) print(f"OK commit v{root_version()}") def push_release(tag: str) -> None: if use_jj(): jj("git", "push", "--bookmark", release_bookmark()) git("push", "origin", tag) else: git("push") git("push", "origin", tag) print("OK push") def cmd_list(selected: list[str]) -> int: for ext in ext_dirs(selected): print(f"{ext.name}\t{read_pkg(ext).get('name')}") return 0 def check_static(dirs: list[Path]) -> int: errors: list[str] = [] for ext in dirs: errors.extend(static_check(ext)) pkg = root_pkg() if pkg.get("private") is not True: errors.append("root: package must have private:true") if pkg.get("pi", {}).get("extensions") != ["extensions/*/index.ts"]: errors.append("root: pi.extensions must be ['extensions/*/index.ts']") for key in ["skills", "prompts", "themes"]: if pkg.get("pi", {}).get(key) != [key]: errors.append(f"root: pi.{key} must be ['{key}']") if errors: for e in errors: print(f"ERROR {e}", file=sys.stderr) return 1 print(f"OK static {len(dirs)} extension package(s)") return 0 def check_build(dirs: list[Path]) -> int: if not shutil.which("bun"): print("ERROR bun not found", file=sys.stderr) return 1 with tempfile.TemporaryDirectory(prefix="pi-ext-build-") as tmp: out_root = Path(tmp) for ext in dirs: try: install(ext) build(ext, out_root) print(f"OK build {ext.name}") except subprocess.CalledProcessError as e: print(f"ERROR build {ext.name}", file=sys.stderr) if e.stdout: print(e.stdout, file=sys.stderr) if e.stderr: print(e.stderr, file=sys.stderr) return e.returncode or 1 print(f"OK build {len(dirs)} extension package(s)") return 0 def cmd_test(selected: list[str]) -> int: dirs = ext_dirs(selected) if not shutil.which("bun"): print("ERROR bun not found", file=sys.stderr) return 1 for ext in dirs: try: install(ext) run_tests(ext) print(f"OK test {ext.name}") except subprocess.CalledProcessError as e: print(f"ERROR test {ext.name}", file=sys.stderr) if e.stdout: print(e.stdout, file=sys.stderr) if e.stderr: print(e.stderr, file=sys.stderr) return e.returncode or 1 print(f"OK test {len(dirs)} extension package(s)") return 0 def cmd_check(selected: list[str]) -> int: dirs = ext_dirs(selected) static = check_static(dirs) if static != 0: return static return check_build(dirs) def cmd_changelog(selected: list[str], model: str | None, write: bool) -> int: dirs = ext_dirs(selected) for ext in dirs: entry = update_changelog(ext, model) if write else generate_changelog_entry(ext, model) print(entry.rstrip()) return 0 def cmd_readme(selected: list[str], model: str | None, write: bool) -> int: dirs = ext_dirs(selected) if write: update_all_readmes(dirs, model) return 0 print(generate_readme(model).rstrip()) for ext in dirs: print() print(generate_ext_readme(ext, model).rstrip()) return 0 def cmd_demo(names: list[str]) -> int: if names: known = {driver: targets for driver, targets in drivers_for(ext_dirs([]))} missing = sorted(set(names) - set(known)) if missing: raise SystemExit(f"unknown demo driver(s): {', '.join(missing)}") update_demo_drivers([(name, known[name]) for name in names]) else: update_demos(ext_dirs([])) return 0 def ensure_ci() -> None: if os.environ.get("PI_EXT_CI_DONE") == "1": return subprocess.run(["mise", "run", "ci"], cwd=ROOT, check=True) os.environ["PI_EXT_CI_DONE"] = "1" def cmd_publish( selected: list[str], *, dry_run: bool, model: str | None, skip_demo: bool, no_push: bool ) -> int: ensure_ci() dirs = ext_dirs(selected) if dry_run: demos = demos_to_update(installed_drivers_for(dirs)) print("DRY RUN publish") print(f"version: v{root_version()}") print("demos: " + (", ".join(name for name, _targets in demos) if demos else "none")) print("README:") print(generate_readme(model).rstrip()) print("repo changelog:") print(generate_repo_changelog_entry(dirs, model).rstrip()) for ext in dirs: print(generate_changelog_entry(ext, model).rstrip()) print("skip commit/tag/push") return 0 demo_paths = [] if skip_demo else update_demos(dirs) update_all_readmes(dirs, model) update_repo_changelog(dirs, model) for ext in dirs: update_changelog(ext, model) commit_release( dirs + demo_paths + [ROOT / "README.md", ROOT / "CHANGELOG.md", ROOT / "package.json"] ) tag = create_tag() if no_push: print("OK push skipped") else: push_release(tag) return 0 def main() -> int: parser = argparse.ArgumentParser() sub = parser.add_subparsers(dest="command", required=True) list_p = sub.add_parser("list") list_p.add_argument("extensions", nargs="*") check_p = sub.add_parser("check") check_p.add_argument("extensions", nargs="*") test_p = sub.add_parser("test") test_p.add_argument("extensions", nargs="*") changelog_p = sub.add_parser("changelog") changelog_p.add_argument("extensions", nargs="+") changelog_p.add_argument("--model") changelog_p.add_argument("--write", action="store_true") readme_p = sub.add_parser("readme") readme_p.add_argument("extensions", nargs="*") readme_p.add_argument("--model") readme_p.add_argument("--write", action="store_true") demo_p = sub.add_parser("demo") demo_p.add_argument("drivers", nargs="*") publish_p = sub.add_parser("publish") publish_p.add_argument("extensions", nargs="*") publish_p.add_argument("--dry-run", action="store_true") publish_p.add_argument("--model") publish_p.add_argument("--skip-demo", action="store_true") publish_p.add_argument("--no-push", action="store_true") args = parser.parse_args() if args.command == "list": return cmd_list(args.extensions) if args.command == "check": return cmd_check(args.extensions) if args.command == "test": return cmd_test(args.extensions) if args.command == "changelog": return cmd_changelog(args.extensions, args.model, args.write) if args.command == "readme": return cmd_readme(args.extensions, args.model, args.write) if args.command == "demo": return cmd_demo(args.drivers) if args.command == "publish": return cmd_publish( args.extensions, dry_run=args.dry_run, model=args.model, skip_demo=args.skip_demo, no_push=args.no_push, ) raise AssertionError(args.command) if __name__ == "__main__": raise SystemExit(main())