pi4py 0.79.7__tar.gz

pi4py-0.79.7/MANIFEST.in

@@ -0,0 +1,5 @@
+include pi4py_build_backend.py
+include tools/prune_npm_runtime.py
+include src/pi4py/py.typed
+recursive-include src/pi4py/_shim *
+recursive-include src/pi4py/_vendor/npm_runtime *

pi4py-0.79.7/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pi4py
+Version: 0.79.7
+Summary: Python wheel wrapper for the @jamwil/pi coding agent
+Author-email: James Williams <jamwil@gmail.com>
+Project-URL: Repository, https://github.com/jamwil/pi4py
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: nodejs-wheel-binaries~=24.14
+
+# pi4py
+
+`pi4py` packages a Python launcher for the `@jamwil/pi-coding-agent` npm CLI.
+
+`@jamwil/pi-coding-agent` is a slow fork of `@mariozechner/pi-coding-agent`.
+
+The primary use for this is to expose a self-contained `pi` executable that can
+be used from python using rpc mode.
+
+## What it installs
+
+- a `pi` console script
+- `nodejs-wheel-binaries` as the bundled Node.js runtime
+- a build hook that installs the pinned `@jamwil/pi-coding-agent` npm package
+  and packages the resulting npm runtime into the Python wheel
+
+## Usage
+
+Install the wheel and invoke the console script with `pi` from the command line
+or from Python with `subprocess.Popen`:
+
+```python
+import subprocess
+
+process = subprocess.Popen(["pi", "--help"])
+process.wait()
+```
+
+The `pi` entry point launches the bundled `@jamwil/pi-coding-agent` CLI with the
+bundled Node.js executable. The npm dependencies, including
+`@jamwil/pi-coding-agent` itself, are installed during wheel build / pip install
+from sdist, not on first launch.
+
+It also routes `npm`, `npx`, `node`, and `corepack` lookups to bundled shims and
+isolates npm global installs under `PI_CODING_AGENT_DIR/npm-global` by default.
+
+Useful environment variables:
+
+- `PI4PY_NPM_PREFIX`: override the npm global prefix used by launched pi
+  subprocesses
+- `PI4PY_SKIP_NPM_BUILD`: skip the npm build hook for metadata/debug builds
+  only; the resulting package will not run unless a runtime is already present
+
+## Updating the pinned pi version
+
+Sync dependencies, then update the pinned npm version:
+
+```bash
+uv sync
+uv run python tools/update_pi_version.py --version 0.66.1-jamwil.0
+```
+
+## Building
+
+```bash
+uv build
+```
+
+Building downloads the pinned `@jamwil/pi-coding-agent` npm package plus its
+production npm dependencies into `src/pi4py/_vendor/npm_runtime`, prunes the
+runtime, and includes it in the wheel.
+
+## Testing the bundled wheel
+
+`uv run pi` may run the local editable/source checkout rather than the wheel
+artifact. To test the actual bundled runtime:
+
+```bash
+uv run --no-editable pi --help
+```

pi4py-0.79.7/README.md

@@ -0,0 +1,70 @@
+# pi4py
+
+`pi4py` packages a Python launcher for the `@jamwil/pi-coding-agent` npm CLI.
+
+`@jamwil/pi-coding-agent` is a slow fork of `@mariozechner/pi-coding-agent`.
+
+The primary use for this is to expose a self-contained `pi` executable that can
+be used from python using rpc mode.
+
+## What it installs
+
+- a `pi` console script
+- `nodejs-wheel-binaries` as the bundled Node.js runtime
+- a build hook that installs the pinned `@jamwil/pi-coding-agent` npm package
+  and packages the resulting npm runtime into the Python wheel
+
+## Usage
+
+Install the wheel and invoke the console script with `pi` from the command line
+or from Python with `subprocess.Popen`:
+
+```python
+import subprocess
+
+process = subprocess.Popen(["pi", "--help"])
+process.wait()
+```
+
+The `pi` entry point launches the bundled `@jamwil/pi-coding-agent` CLI with the
+bundled Node.js executable. The npm dependencies, including
+`@jamwil/pi-coding-agent` itself, are installed during wheel build / pip install
+from sdist, not on first launch.
+
+It also routes `npm`, `npx`, `node`, and `corepack` lookups to bundled shims and
+isolates npm global installs under `PI_CODING_AGENT_DIR/npm-global` by default.
+
+Useful environment variables:
+
+- `PI4PY_NPM_PREFIX`: override the npm global prefix used by launched pi
+  subprocesses
+- `PI4PY_SKIP_NPM_BUILD`: skip the npm build hook for metadata/debug builds
+  only; the resulting package will not run unless a runtime is already present
+
+## Updating the pinned pi version
+
+Sync dependencies, then update the pinned npm version:
+
+```bash
+uv sync
+uv run python tools/update_pi_version.py --version 0.66.1-jamwil.0
+```
+
+## Building
+
+```bash
+uv build
+```
+
+Building downloads the pinned `@jamwil/pi-coding-agent` npm package plus its
+production npm dependencies into `src/pi4py/_vendor/npm_runtime`, prunes the
+runtime, and includes it in the wheel.
+
+## Testing the bundled wheel
+
+`uv run pi` may run the local editable/source checkout rather than the wheel
+artifact. To test the actual bundled runtime:
+
+```bash
+uv run --no-editable pi --help
+```

pi4py-0.79.7/pi4py_build_backend.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from setuptools import build_meta as _setuptools_build_meta
+from setuptools.build_meta import *  # noqa: F401,F403 - re-export PEP 517 hooks
+
+from tools.prune_npm_runtime import prune_npm_runtime
+
+try:
+    from nodejs_wheel.executable import npm
+except Exception as exc:  # pragma: no cover - build-time dependency error path
+    npm = None  # type: ignore[assignment]
+    _NODE_IMPORT_ERROR = exc
+else:
+    _NODE_IMPORT_ERROR = None
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+RUNTIME_DIR = PROJECT_ROOT / "src" / "pi4py" / "_vendor" / "npm_runtime"
+RUNTIME_METADATA = PROJECT_ROOT / "src" / "pi4py" / "_vendor" / "runtime.json"
+PI_PACKAGE_NAME = "@jamwil/pi-coding-agent"
+PI_VERSION = "0.79.7-jamwil.0"
+
+
+def _run_npm(args: list[str], cwd: Path, env: dict[str, str]) -> None:
+    if npm is None:
+        raise RuntimeError(
+            "nodejs-wheel-binaries is required to build the pi runtime"
+        ) from _NODE_IMPORT_ERROR
+    npm(args, cwd=str(cwd), env=env, check=True)
+
+
+def _build_env() -> dict[str, str]:
+    env = os.environ.copy()
+    env.setdefault("npm_config_audit", "false")
+    env.setdefault("npm_config_fund", "false")
+    env.setdefault("npm_config_update_notifier", "false")
+    env.setdefault("npm_config_progress", "false")
+    env.setdefault("npm_config_loglevel", "warn")
+    return env
+
+
+def _install_runtime(runtime_project_dir: Path, env: dict[str, str]) -> None:
+    (runtime_project_dir / "package.json").write_text(
+        json.dumps(
+            {
+                "name": "pi4py-runtime",
+                "private": True,
+                "dependencies": {PI_PACKAGE_NAME: PI_VERSION},
+            },
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    _run_npm(
+        [
+            "install",
+            "--omit=dev",
+            "--omit=optional",
+            "--ignore-scripts",
+            "--no-audit",
+            "--no-fund",
+        ],
+        cwd=runtime_project_dir,
+        env=env,
+    )
+
+    cli_js = runtime_project_dir / "node_modules" / "@jamwil" / "pi-coding-agent" / "dist" / "cli.js"
+    if not cli_js.is_file():
+        raise RuntimeError(f"Installed pi CLI was not found: {cli_js}")
+
+    shutil.rmtree(runtime_project_dir / "node_modules" / ".bin", ignore_errors=True)
+
+
+def _clean_runtime() -> None:
+    shutil.rmtree(RUNTIME_DIR, ignore_errors=True)
+    RUNTIME_METADATA.unlink(missing_ok=True)
+
+
+def _build_pi_runtime() -> None:
+    if os.environ.get("PI4PY_SKIP_NPM_BUILD"):
+        return
+
+    _clean_runtime()
+    env = _build_env()
+
+    with tempfile.TemporaryDirectory(prefix="pi4py-build-") as temp_dir_name:
+        temp_dir = Path(temp_dir_name)
+        runtime_project_dir = temp_dir / "runtime"
+        runtime_project_dir.mkdir()
+
+        _install_runtime(runtime_project_dir, env)
+
+        RUNTIME_DIR.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(runtime_project_dir / "node_modules", RUNTIME_DIR / "node_modules")
+        prune_npm_runtime(RUNTIME_DIR / "node_modules")
+        shutil.copy2(runtime_project_dir / "package.json", RUNTIME_DIR / "package.json")
+        package_lock = runtime_project_dir / "package-lock.json"
+        if package_lock.is_file():
+            shutil.copy2(package_lock, RUNTIME_DIR / "package-lock.json")
+
+    RUNTIME_METADATA.write_text(
+        json.dumps(
+            {
+                "package": PI_PACKAGE_NAME,
+                "version": PI_VERSION,
+                "source": "npm",
+                "built_at": datetime.now(timezone.utc).isoformat(),
+            },
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    _build_pi_runtime()
+    return _setuptools_build_meta.build_wheel(wheel_directory, config_settings, metadata_directory)
+
+
+def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+    _build_pi_runtime()
+    return _setuptools_build_meta.build_editable(wheel_directory, config_settings, metadata_directory)
+
+
+def build_sdist(sdist_directory, config_settings=None):
+    # Keep sdists source-only. Wheels built from the sdist will run build_wheel
+    # and generate src/pi4py/_vendor/npm_runtime then.
+    _clean_runtime()
+    return _setuptools_build_meta.build_sdist(sdist_directory, config_settings)

pi4py-0.79.7/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "pi4py"
+version = "0.79.7"
+description = "Python wheel wrapper for the @jamwil/pi coding agent"
+readme = "README.md"
+authors = [
+    { name = "James Williams", email = "jamwil@gmail.com" }
+]
+requires-python = ">=3.9"
+dependencies = [
+    "nodejs-wheel-binaries~=24.14",
+]
+
+[project.urls]
+Repository = "https://github.com/jamwil/pi4py"
+
+[project.scripts]
+pi = "pi4py._launcher:main"
+
+[build-system]
+requires = ["setuptools>=80", "wheel", "nodejs-wheel-binaries~=24.14"]
+build-backend = "pi4py_build_backend"
+backend-path = ["."]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]

pi4py-0.79.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pi4py-0.79.7/src/pi4py/__init__.py

@@ -0,0 +1 @@
+"""pi4py package."""

pi4py-0.79.7/src/pi4py/_launcher.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from pi4py._nodejs import node_executable
+from pi4py._runtime import ensure_cli
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+_SHIM_DIR = _PACKAGE_DIR / "_shim"
+
+
+def _build_env() -> dict[str, str]:
+    env = os.environ.copy()
+    path = env.get("PATH")
+    shim_dir = str(_SHIM_DIR)
+    env["PATH"] = shim_dir if not path else os.pathsep.join([shim_dir, path])
+    env["PI4PY_PYTHON_EXECUTABLE"] = sys.executable
+
+    agent_dir = Path(env.get("PI_CODING_AGENT_DIR", Path.home() / ".pi" / "agent"))
+    npm_prefix = Path(env.get("PI4PY_NPM_PREFIX", agent_dir / "npm-global"))
+    npm_prefix.mkdir(parents=True, exist_ok=True)
+    env.setdefault("NPM_CONFIG_PREFIX", str(npm_prefix))
+    env.setdefault("npm_config_prefix", str(npm_prefix))
+
+    env.setdefault("npm_config_update_notifier", "false")
+    env.setdefault("npm_config_fund", "false")
+    return env
+
+
+def _argv(env: dict[str, str]) -> list[str]:
+    try:
+        pi_cli = ensure_cli()
+    except Exception as exc:
+        raise SystemExit(f"Unable to locate bundled @jamwil/pi-coding-agent runtime: {exc}") from exc
+
+    return [node_executable(), str(pi_cli), *sys.argv[1:]]
+
+
+def main() -> int:
+    env = _build_env()
+    argv = _argv(env)
+
+    if os.name != "nt":
+        os.execvpe(argv[0], argv, env)
+
+    return subprocess.call(argv, env=env, close_fds=False)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pi4py-0.79.7/src/pi4py/_nodejs.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from nodejs_wheel import executable as nodejs_executable
+
+_ROOT_DIR = Path(nodejs_executable.ROOT_DIR)
+
+
+def node_executable() -> str:
+    if os.name == "nt":
+        return str(_ROOT_DIR / "node.exe")
+    return str(_ROOT_DIR / "bin" / "node")
+
+
+def npm_cli() -> str:
+    return str(_ROOT_DIR / "lib" / "node_modules" / "npm" / "bin" / "npm-cli.js")
+
+
+def npx_cli() -> str:
+    return str(_ROOT_DIR / "lib" / "node_modules" / "npm" / "bin" / "npx-cli.js")
+
+
+def corepack_cli() -> str:
+    return str(_ROOT_DIR / "lib" / "node_modules" / "corepack" / "dist" / "corepack.js")
+
+
+def command_argv(command: str, args: list[str]) -> list[str]:
+    if command == "node":
+        return [node_executable(), *args]
+    if command == "npm":
+        return [node_executable(), npm_cli(), *args]
+    if command == "npx":
+        return [node_executable(), npx_cli(), *args]
+    if command == "corepack":
+        return [node_executable(), corepack_cli(), *args]
+    raise ValueError(f"Unsupported nodejs helper command: {command}")
+
+
+def run(command: str, args: list[str]) -> int:
+    argv = command_argv(command, args)
+    if os.name != "nt":
+        os.execv(argv[0], argv)
+    return subprocess.call(argv, close_fds=False)
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        raise SystemExit("Usage: python -m pi4py._nodejs <node|npm|npx|corepack> [args...]")
+    return run(sys.argv[1], sys.argv[2:])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pi4py-0.79.7/src/pi4py/_pi.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+PI_PACKAGE_NAME = "@jamwil/pi-coding-agent"
+PI_VERSION = "0.79.7-jamwil.0"

pi4py-0.79.7/src/pi4py/_runtime.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+_RUNTIME_DIR = _PACKAGE_DIR / "_vendor" / "npm_runtime"
+
+
+def install_root() -> Path:
+    return _RUNTIME_DIR
+
+
+def cli_path() -> Path:
+    return install_root() / "node_modules" / "@jamwil" / "pi-coding-agent" / "dist" / "cli.js"
+
+
+def ensure_cli() -> Path:
+    pi_cli = cli_path()
+    if not pi_cli.is_file():
+        raise RuntimeError(
+            "The bundled pi runtime is missing. Reinstall pi4py from a wheel or rebuild it "
+            "without PI4PY_SKIP_NPM_BUILD."
+        )
+    return pi_cli

pi4py-0.79.7/src/pi4py/_shim/corepack

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+PYTHON_EXECUTABLE="${PI4PY_PYTHON_EXECUTABLE:-python}"
+exec "$PYTHON_EXECUTABLE" -m pi4py._nodejs corepack "$@"

pi4py-0.79.7/src/pi4py/_shim/corepack.cmd

@@ -0,0 +1,4 @@
+@echo off
+set "PYTHON_EXECUTABLE=%PI4PY_PYTHON_EXECUTABLE%"
+if not defined PYTHON_EXECUTABLE set "PYTHON_EXECUTABLE=python"
+"%PYTHON_EXECUTABLE%" -m pi4py._nodejs corepack %*

pi4py-0.79.7/src/pi4py/_shim/node

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+PYTHON_EXECUTABLE="${PI4PY_PYTHON_EXECUTABLE:-python}"
+exec "$PYTHON_EXECUTABLE" -m pi4py._nodejs node "$@"

pi4py-0.79.7/src/pi4py/_shim/node.cmd

@@ -0,0 +1,4 @@
+@echo off
+set "PYTHON_EXECUTABLE=%PI4PY_PYTHON_EXECUTABLE%"
+if not defined PYTHON_EXECUTABLE set "PYTHON_EXECUTABLE=python"
+"%PYTHON_EXECUTABLE%" -m pi4py._nodejs node %*

pi4py-0.79.7/src/pi4py/_shim/npm

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+PYTHON_EXECUTABLE="${PI4PY_PYTHON_EXECUTABLE:-python}"
+exec "$PYTHON_EXECUTABLE" -m pi4py._nodejs npm "$@"

pi4py-0.79.7/src/pi4py/_shim/npm.cmd

@@ -0,0 +1,4 @@
+@echo off
+set "PYTHON_EXECUTABLE=%PI4PY_PYTHON_EXECUTABLE%"
+if not defined PYTHON_EXECUTABLE set "PYTHON_EXECUTABLE=python"
+"%PYTHON_EXECUTABLE%" -m pi4py._nodejs npm %*

pi4py-0.79.7/src/pi4py/_shim/npx

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+set -eu
+PYTHON_EXECUTABLE="${PI4PY_PYTHON_EXECUTABLE:-python}"
+exec "$PYTHON_EXECUTABLE" -m pi4py._nodejs npx "$@"

pi4py-0.79.7/src/pi4py/_shim/npx.cmd

@@ -0,0 +1,4 @@
+@echo off
+set "PYTHON_EXECUTABLE=%PI4PY_PYTHON_EXECUTABLE%"
+if not defined PYTHON_EXECUTABLE set "PYTHON_EXECUTABLE=python"
+"%PYTHON_EXECUTABLE%" -m pi4py._nodejs npx %*

pi4py-0.79.7/src/pi4py.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pi4py
+Version: 0.79.7
+Summary: Python wheel wrapper for the @jamwil/pi coding agent
+Author-email: James Williams <jamwil@gmail.com>
+Project-URL: Repository, https://github.com/jamwil/pi4py
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: nodejs-wheel-binaries~=24.14
+
+# pi4py
+
+`pi4py` packages a Python launcher for the `@jamwil/pi-coding-agent` npm CLI.
+
+`@jamwil/pi-coding-agent` is a slow fork of `@mariozechner/pi-coding-agent`.
+
+The primary use for this is to expose a self-contained `pi` executable that can
+be used from python using rpc mode.
+
+## What it installs
+
+- a `pi` console script
+- `nodejs-wheel-binaries` as the bundled Node.js runtime
+- a build hook that installs the pinned `@jamwil/pi-coding-agent` npm package
+  and packages the resulting npm runtime into the Python wheel
+
+## Usage
+
+Install the wheel and invoke the console script with `pi` from the command line
+or from Python with `subprocess.Popen`:
+
+```python
+import subprocess
+
+process = subprocess.Popen(["pi", "--help"])
+process.wait()
+```
+
+The `pi` entry point launches the bundled `@jamwil/pi-coding-agent` CLI with the
+bundled Node.js executable. The npm dependencies, including
+`@jamwil/pi-coding-agent` itself, are installed during wheel build / pip install
+from sdist, not on first launch.
+
+It also routes `npm`, `npx`, `node`, and `corepack` lookups to bundled shims and
+isolates npm global installs under `PI_CODING_AGENT_DIR/npm-global` by default.
+
+Useful environment variables:
+
+- `PI4PY_NPM_PREFIX`: override the npm global prefix used by launched pi
+  subprocesses
+- `PI4PY_SKIP_NPM_BUILD`: skip the npm build hook for metadata/debug builds
+  only; the resulting package will not run unless a runtime is already present
+
+## Updating the pinned pi version
+
+Sync dependencies, then update the pinned npm version:
+
+```bash
+uv sync
+uv run python tools/update_pi_version.py --version 0.66.1-jamwil.0
+```
+
+## Building
+
+```bash
+uv build
+```
+
+Building downloads the pinned `@jamwil/pi-coding-agent` npm package plus its
+production npm dependencies into `src/pi4py/_vendor/npm_runtime`, prunes the
+runtime, and includes it in the wheel.
+
+## Testing the bundled wheel
+
+`uv run pi` may run the local editable/source checkout rather than the wheel
+artifact. To test the actual bundled runtime:
+
+```bash
+uv run --no-editable pi --help
+```

pi4py-0.79.7/src/pi4py.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+MANIFEST.in
+README.md
+pi4py_build_backend.py
+pyproject.toml
+src/pi4py/__init__.py
+src/pi4py/_launcher.py
+src/pi4py/_nodejs.py
+src/pi4py/_pi.py
+src/pi4py/_runtime.py
+src/pi4py/py.typed
+src/pi4py.egg-info/PKG-INFO
+src/pi4py.egg-info/SOURCES.txt
+src/pi4py.egg-info/dependency_links.txt
+src/pi4py.egg-info/entry_points.txt
+src/pi4py.egg-info/requires.txt
+src/pi4py.egg-info/top_level.txt
+src/pi4py/_shim/corepack
+src/pi4py/_shim/corepack.cmd
+src/pi4py/_shim/node
+src/pi4py/_shim/node.cmd
+src/pi4py/_shim/npm
+src/pi4py/_shim/npm.cmd
+src/pi4py/_shim/npx
+src/pi4py/_shim/npx.cmd
+tools/prune_npm_runtime.py

pi4py-0.79.7/src/pi4py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pi4py-0.79.7/src/pi4py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pi = pi4py._launcher:main

pi4py-0.79.7/src/pi4py.egg-info/requires.txt

@@ -0,0 +1 @@
+nodejs-wheel-binaries~=24.14

pi4py-0.79.7/src/pi4py.egg-info/top_level.txt

@@ -0,0 +1 @@
+pi4py

pi4py-0.79.7/tools/prune_npm_runtime.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_RUNTIME_ROOT = PROJECT_ROOT / "src" / "pi4py" / "_vendor" / "npm_runtime" / "node_modules"
+
+REMOVABLE_DIRECTORIES = {
+    ".github",
+    ".husky",
+    "__mocks__",
+    "__tests__",
+    "benchmark",
+    "benchmarks",
+    "coverage",
+    "docs",
+    "example",
+    "examples",
+    "scripts",
+    "test",
+    "tests",
+}
+
+REMOVABLE_SUFFIXES = (
+    ".d.cts.map",
+    ".d.mts.map",
+    ".d.ts.map",
+    ".js.map",
+    ".mjs.map",
+    ".cjs.map",
+    ".cts",
+    ".mts",
+    ".ts",
+    ".tsx",
+    ".map",
+)
+
+REMOVABLE_NAMES = {
+    ".babelrc",
+    ".editorconfig",
+    ".eslintignore",
+    ".eslintrc",
+    ".eslintrc.cjs",
+    ".eslintrc.js",
+    ".gitattributes",
+    ".gitignore",
+    ".npmignore",
+    ".nycrc",
+    ".prettierignore",
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yaml",
+    ".travis.yml",
+    "appveyor.yml",
+    "bower.json",
+    "changelog",
+    "changelog.md",
+    "changelog.markdown",
+    "contributing.md",
+    "eslint.config.js",
+    "gruntfile.js",
+    "gulpfile.js",
+    "makefile",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "readme",
+    "readme.md",
+    "readme.markdown",
+    "rollup.config.js",
+    "tsconfig.json",
+    "tsconfig.build.json",
+    "typedoc.json",
+    "yarn.lock",
+}
+
+# Keep pi's own user-facing docs/examples because the system prompt points to them.
+KEEP_PREFIX_PARTS = {
+    ("@jamwil", "pi-coding-agent", "docs"),
+    ("@jamwil", "pi-coding-agent", "examples"),
+}
+
+
+def _relative_parts(path: Path, root: Path) -> tuple[str, ...]:
+    try:
+        return path.relative_to(root).parts
+    except ValueError:
+        return ()
+
+
+def _is_kept(path: Path, root: Path) -> bool:
+    parts = _relative_parts(path, root)
+    if any(parts[: len(prefix)] == prefix for prefix in KEEP_PREFIX_PARTS):
+        return True
+    return parts[:2] == ("@jamwil", "pi-coding-agent") and path.name.lower() in {"readme.md", "changelog.md"}
+
+
+def prune_npm_runtime(root: Path = DEFAULT_RUNTIME_ROOT) -> None:
+    if not root.is_dir():
+        return
+
+    for path in sorted(root.rglob("*"), key=lambda p: len(p.parts), reverse=True):
+        if _is_kept(path, root):
+            continue
+
+        lower_name = path.name.lower()
+        if path.is_dir():
+            if lower_name in REMOVABLE_DIRECTORIES:
+                shutil.rmtree(path, ignore_errors=True)
+            continue
+
+        if not path.is_file():
+            continue
+
+        if lower_name in REMOVABLE_NAMES or lower_name.endswith(REMOVABLE_SUFFIXES):
+            path.unlink()
+
+
+def main() -> int:
+    prune_npm_runtime()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())