repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

scripts/extensions.py

Raw
#!/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:
  <!-- demo:NAME:start --> ... <!-- demo:NAME:end -->.
- 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 "<missing>"}

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 "<missing>"}

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())