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 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, 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.
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.
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 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, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)


def run_tests(ext: Path) -> None:
    subprocess.run(
        ["bun", "test"],
        cwd=ext,
        check=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        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:
    tag = latest_release_tag()
    if not tag:
        return True
    rel = str(path.relative_to(ROOT))
    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", "-p", "--tools", "read,bash,grep,find,ls"]
    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"}

Inspect source/readme/tests/changelog under the path. Do not edit files.
Use tools if useful. You are in an ephemeral Pi session with normal tools/extensions loaded.

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

Inspect changed extension source/readmes/tests if useful. 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("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 cmd_publish(selected: list[str], *, dry_run: bool, model: str | None, skip_demo: bool, no_push: bool) -> int:
    dirs = ext_dirs(selected)
    checked = cmd_check(selected)
    if checked != 0:
        return checked
    tested = cmd_test(selected)
    if tested != 0:
        return tested

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