#!/usr/bin/env python3 """Pi extension repo workflow.""" from __future__ import annotations import argparse import importlib.util import json import os import re 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" ROOT_INSTALL_DONE = False 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 is_allowed_test_import(file: Path, resolved: Path) -> bool: try: resolved.relative_to((ROOT / "test").resolve()) except ValueError: return False return "__tests__" in file.parts 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 {} if dev.get(HARNESS) is None: err(errors, ext, f"missing devDependency {HARNESS}") # test:harness script is optional; vitest discovers tests by convention 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:")) } 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: if not is_allowed_test_import(file, resolved): 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: global ROOT_INSTALL_DONE if ROOT_INSTALL_DONE: return subprocess.run(["npm", "ci", "--silent"], cwd=ROOT, check=True) ROOT_INSTALL_DONE = 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("workspaces") != ["extensions/*"]: errors.append("root: workspaces must be ['extensions/*']") 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 cmd_test(selected: list[str]) -> int: dirs = ext_dirs(selected) args = [str(d.relative_to(ROOT)) for d in dirs] if dirs else [] subprocess.run(["npm", "run", "test", "--", *args], cwd=ROOT, check=True) return 0 def cmd_check(selected: list[str]) -> int: return check_static(ext_dirs(selected)) 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", ROOT / "package-lock.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())