ppkit 0.1.0__py3-none-any.whl

pp/lib/session.py

@@ -0,0 +1,31 @@
+"""Who is calling pp: a person's shell, or an agent session.
+
+Claude Code puts its session's identity in the environment of every command it runs (CLAUDE_CODE_SESSION_ID,
+CLAUDE_PID, and TMUX_PANE when it runs inside tmux). pp records that identity as a queued job's owner, so
+`pp queue wait --mine` finds the jobs a session queued. It strips it from anything pp starts on its own (workers,
+jobs, hooks): a process that inherits a session's identity looks, to itself and to every tool it runs, as if it
+were inside that session.
+"""
+from __future__ import annotations
+
+import os
+
+# a session's identity, never configuration: CLAUDE_CODE_USE_BEDROCK and friends are auth settings and stay
+SESSION_VARS = ("CLAUDECODE", "AI_AGENT", "CLAUDE_PID", "CLAUDE_EFFORT", "CLAUDE_CODE_SESSION_ID",
+                "CLAUDE_CODE_CHILD_SESSION", "CLAUDE_CODE_SESSION_ATTENDED", "CLAUDE_CODE_MESSAGING_SOCKET",
+                "CLAUDE_CODE_MESSAGING_TOKEN", "CLAUDE_CODE_ENTRYPOINT", "CLAUDE_CODE_EXECPATH", "TMUX_PANE")
+
+
+def caller(env: dict | None = None) -> dict | None:
+    """The calling agent session, {session, cwd}, or None when a person (or a script) calls."""
+    env = os.environ if env is None else env
+    sid = env.get("CLAUDE_CODE_SESSION_ID")
+    return {"session": sid, "cwd": os.getcwd()} if sid else None
+
+
+def scrubbed_env(env: dict | None = None) -> dict:
+    """A copy of env without any session's identity."""
+    env = dict(os.environ if env is None else env)
+    for k in SESSION_VARS:
+        env.pop(k, None)
+    return env

pp/lib/ui.py

@@ -0,0 +1,189 @@
+"""Terminal helpers shared by commands: argument parsers, confirmation, tables, colour, human units."""
+from __future__ import annotations
+
+import argparse
+import re
+import json
+import os
+import sys
+import time
+import unicodedata
+
+
+def parser(cmd: str, doc: str | None, **kw) -> argparse.ArgumentParser:
+    """An ArgumentParser for `pp <cmd>`: the module docstring is the help text, kept verbatim."""
+    return argparse.ArgumentParser(prog=f"pp {cmd}", description=doc,
+                                   formatter_class=argparse.RawDescriptionHelpFormatter, **kw)
+
+
+def parse_intermixed(p: argparse.ArgumentParser, argv: list[str]) -> argparse.Namespace:
+    """p.parse_intermixed_args(argv), the same on every Python pp supports: options may sit between positionals
+    (`pp batch rename ' ' _ -r .`, which plain parse_args gets wrong on 3.11 and early 3.12), and after `--` every
+    argument is a positional. Those versions' intermixed parse also lost `--` and read a later '-x' as an
+    option, so such arguments pass through argparse as placeholders that cannot look like options."""
+    if "--" not in argv:
+        return p.parse_intermixed_args(argv)
+    i = argv.index("--")
+    held = {f"\0{n}": a for n, a in enumerate(argv[i + 1:]) if a.startswith("-")}
+    tail = [f"\0{n}" if a.startswith("-") else a for n, a in enumerate(argv[i + 1:])]
+    ns = p.parse_intermixed_args(argv[:i + 1] + tail)
+    for k, v in vars(ns).items():
+        if isinstance(v, str):
+            setattr(ns, k, held.get(v, v))
+        elif isinstance(v, list):
+            setattr(ns, k, [held.get(x, x) if isinstance(x, str) else x for x in v])
+    return ns
+
+
+def die(msg: str, code: int = 1):
+    """Print `pp: msg` to stderr and exit with code (1 failure, 2 usage/refusal)."""
+    print(f"pp: {msg}", file=sys.stderr)
+    raise SystemExit(code)
+
+
+def warn(msg: str):
+    print(f"pp: {msg}", file=sys.stderr)
+
+
+def confirm(prompt: str, yes: bool = False) -> bool:
+    """True to proceed. -y always proceeds; without a terminal to ask on we refuse rather than guess."""
+    sys.stdout.flush()      # the plan printed so far comes before the question or the refusal, even into a pipe
+    if yes:
+        return True
+    if not sys.stdin.isatty():
+        print(f"{prompt} There is no terminal to ask at; pass -y to proceed.", file=sys.stderr)
+        return False
+    try:
+        return input(f"{prompt} [y/N] ").strip().lower() in ("y", "yes")
+    except EOFError:
+        return False
+
+
+# ---- colour ---------------------------------------------------------------------------------------
+
+_STYLES = {"bold": "1", "dim": "2", "red": "31", "green": "32", "yellow": "33", "blue": "34", "magenta": "35", "cyan": "36"}
+
+
+def color_on(stream=None) -> bool:
+    stream = stream or sys.stdout
+    return stream.isatty() and not os.environ.get("NO_COLOR") and os.environ.get("TERM") != "dumb"
+
+
+def c(text: str, *styles: str, stream=None) -> str:
+    if not styles or not color_on(stream):
+        return text
+    return "\033[" + ";".join(_STYLES[s] for s in styles) + "m" + text + "\033[0m"
+
+
+# ---- output ---------------------------------------------------------------------------------------
+
+# every control character but tab, the C1 range (\x80-\x9f) among them: a terminal reads \x9b as a
+# control sequence introducer, the way it reads \x1b[
+_CTRL = re.compile(r"[\x00-\x08\x0a-\x1f\x7f-\x9f]")
+_CTRL_TAB = re.compile(r"[\x00-\x1f\x7f-\x9f]")
+_SGR = re.compile(r"\x1b\[[0-9;]*m")                  # what c() wraps a cell in: bytes, no columns
+
+
+def printable(text: str, tabs: bool = True) -> str:
+    """Text from elsewhere (another program's argv, a plugin's file, git's output, a requested URL) made safe
+    to print: control characters shown as \\n, \\x1b and so on, so an escape sequence cannot redraw the
+    terminal around what the user is reading. A tab stays a tab unless tabs is False (in a table, where it
+    would break the columns). The one escaper in pp: CONTRIBUTING.md, "Adding a command"."""
+    return (_CTRL if tabs else _CTRL_TAB).sub(lambda m: repr(m.group())[1:-1], text)
+
+
+def _char_width(ch: str) -> int:
+    """How many columns one character takes, which width() and cut() both count in, so a cut and the measure
+    that decided on it can never disagree.
+
+    A combining mark is drawn on the character before it, so it takes no column of its own: an accent in an
+    NFD name (a copy from a Mac, an unzipped archive, some input methods) is such a mark, and so are the
+    other zero-width characters, a joiner and a variation selector among them. A character East Asian width
+    calls wide or fullwidth (a CJK name, a fullwidth form) takes two columns. Anything else takes one."""
+    if unicodedata.category(ch) in ("Mn", "Me", "Cf"):
+        return 0
+    return 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+
+
+def width(text: str) -> int:
+    """How many columns text takes on a terminal, which is what anything lining text up has to count.
+
+    A colour from c() is escape bytes the terminal prints nothing for, so they count for nothing; every other
+    character counts what _char_width says. Counting characters instead pads a coloured cell nine columns too
+    far, a CJK name half as far as it needs, and an NFD name one column per accent too far."""
+    return sum(_char_width(ch) for ch in _SGR.sub("", text))
+
+
+def pad(text: str, to: int) -> str:
+    """text with spaces after it up to `to` printed columns, as str.ljust does with characters."""
+    return text + " " * max(to - width(text), 0)
+
+
+def cut(text: str, to: int) -> str:
+    """text, no wider than `to` printed columns, with an ellipsis where it was cut. Cut by columns, so a wide
+    character is kept whole or left out, never split across the edge, and a combining mark stays with the
+    character it is drawn on. For text without colours: a colour cut in half would run on past the cell."""
+    if width(text) <= to:
+        return text
+    out, used = [], 0
+    for ch in text:
+        w = _char_width(ch)
+        if used + w > to - 1:
+            break
+        out.append(ch)
+        used += w
+    return "".join(out) + "…"
+
+
+def table(rows: list[list], headers: list[str] | None = None, indent: str = "") -> str:
+    """Left-aligned columns; the last column is never padded. Cells are str()'d, with a newline or carriage return
+    shown as \\n or \\r, so no cell starts a row of its own. Cells may carry c()'s colours; text from elsewhere
+    goes through printable() first.
+
+    Columns are counted and padded in printed columns (width()), so a coloured cell and a CJK name line up
+    like any other and no call site has to know what its cells hold."""
+    rows = [[("" if v is None else str(v)).replace("\n", "\\n").replace("\r", "\\r") for v in r] for r in rows]
+    allr = ([headers] if headers else []) + rows
+    if not allr:
+        return ""
+    n = max(len(r) for r in allr)
+    widths = [max((width(r[i]) for r in allr if i < len(r)), default=0) for i in range(n)]
+    out = []
+    for k, r in enumerate(allr):
+        cells = [pad(cell, widths[i]) if i < len(r) - 1 else cell for i, cell in enumerate(r)]
+        line = indent + "  ".join(cells)
+        out.append(c(line, "bold") if headers and k == 0 else line)
+    return "\n".join(out)
+
+
+def print_json(obj) -> None:
+    json.dump(obj, sys.stdout, indent=2, default=str)
+    sys.stdout.write("\n")
+
+
+def human_size(n: float) -> str:
+    for unit in ("B", "K", "M", "G", "T"):
+        if abs(n) < 1024 or unit == "T":
+            return f"{n:.0f}{unit}" if unit == "B" else f"{n:.1f}{unit}"
+        n /= 1024
+    return f"{n:.1f}T"
+
+
+def human_duration(s: float | None) -> str:
+    if s is None:
+        return "-"
+    s = int(s)
+    if s < 60:
+        return f"{s}s"
+    if s < 3600:
+        return f"{s // 60}m{s % 60:02d}s"
+    if s < 86400:
+        return f"{s // 3600}h{(s % 3600) // 60:02d}m"
+    return f"{s // 86400}d{(s % 86400) // 3600:02d}h"
+
+
+def human_age(ts: float | None, now: float | None = None) -> str:
+    """'3m ago' style age of a unix timestamp."""
+    if not ts:
+        return "-"
+    return human_duration((now or time.time()) - ts) + " ago"

ppkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,330 @@
+Metadata-Version: 2.4
+Name: ppkit
+Version: 0.1.0
+Summary: A CLI kit for user & agents
+Keywords: cli,job queue,gpu,agents,toolkit
+Author: The pp Authors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Project-URL: Changelog, https://github.com/xflash96/pp/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/xflash96/pp
+Project-URL: Issues, https://github.com/xflash96/pp/issues
+Description-Content-Type: text/markdown
+
+# pp
+
+[![ci](https://github.com/xflash96/pp/actions/workflows/ci.yml/badge.svg)](https://github.com/xflash96/pp/actions/workflows/ci.yml)
+[![pypi](https://img.shields.io/pypi/v/ppkit)](https://pypi.org/project/ppkit/)
+[![license](https://img.shields.io/github/license/xflash96/pp)](https://github.com/xflash96/pp/blob/main/LICENSE)
+
+A CLI kit for user & agents.
+
+pp gathers the shell chores that come up when you work next to coding
+agents such as Claude Code on one Linux machine. Long jobs wait their turn
+for the GPU. An agent finds out how its job ended without anyone watching a
+terminal. The copy of a tool you use every day is one that passed its tests,
+not the one being edited.
+
+Every command shows what it will do before it does it, and works the same
+when a person or an agent runs it. [Try it](#try-it) queues a first job.
+
+## Features
+
+- [`pp queue`](#queues) runs commands later, in named queues. A job starts
+  when the GPU memory, CPUs, RAM or counters it asks for are free, and it
+  can have a timeout, retries and a hook for when it ends.
+- [`pp queue wait`](#working-with-agents) blocks until jobs end, then says
+  how each one ended. An agent runs it in the background instead of polling.
+- [`pp promote`](#releases) releases a project from a git commit, tests the
+  copy, and switches to it only if the tests pass.
+- [`pp kill`](#everyday-tools) stops processes by pid, port or pattern, and
+  never the shell that asked.
+- [`pp batch`](#everyday-tools) renames files, or runs a command on each one,
+  with a preview and undo.
+- [`pp http`](#everyday-tools) shows project folders in a browser, with
+  markdown and code rendered.
+- [`pp cmd`](#your-own-commands) writes your own commands, and adds other
+  people's from git.
+
+pp needs no packages beyond Python itself, and it completes in zsh and bash.
+
+## How it works
+
+Each command is one Python file. pp looks for them when it runs: its own in
+`pp/commands/`, yours in `~/.config/pp/commands/`, the plugins you added
+with `pp cmd add`, the folders listed in `PP_PATH`, and any program named
+`pp-NAME` on your `PATH`. The first one found wins, so a plugin cannot hide
+a built-in or one of yours. `pp` lists commands without loading them, so
+one broken command cannot break the others.
+`pp help NAME` prints a command's manual, with examples.
+
+Everything pp keeps is in plain files:
+
+```
+~/.config/pp/config.toml       settings, a table per command
+~/.config/pp/commands/         your own commands
+.pp.toml                       a project's settings, at its root
+~/.local/state/pp/             queues, job logs, the rename journal
+~/.local/share/pp/releases/    what pp promote released
+~/.local/share/pp/plugins/     plugins, one git clone each
+```
+
+A queue has a worker, a background process that `pp queue add` starts when
+it is not running. It runs each job in its own process group, in the
+directory the job was added from, with the `PATH` and virtualenv of the
+shell that added it.
+
+## Install
+
+pp runs on Linux, with Python 3.11 or later. Install it as a tool, in an
+environment of its own:
+
+```
+uv tool install ppkit        # or: pipx install ppkit
+pp --version
+```
+
+For completion, add `source <(pp completion zsh)` to `~/.zshrc` after
+`compinit`, or `source <(pp completion bash)` to `~/.bashrc`. To change pp
+itself, run it from a clone instead ([CONTRIBUTING.md](https://github.com/xflash96/pp/blob/main/CONTRIBUTING.md)).
+
+## Try it
+
+```
+pp queue add -- sh -c 'echo working; sleep 3; echo hello'   # job 1, in the default queue; its worker starts
+pp queue                                       # job 1 running, with its last line of output: working
+pp queue wait 1                                # waits, then: done 1 rc=0 3s
+pp queue log 1                                 # working, then hello
+pp queue add --retries 1 --retry-delay 1s -- sh -c 'echo trying; exit 3'
+pp queue wait 2                                # FAILED 2 rc=3, after two tries, with the end of its log
+```
+
+`wait` exits with 0 when every job succeeded and 1 when one failed, so it
+fits in a script: `pp queue wait 2 && ./next-step.sh`.
+
+A job that needs a GPU says how much memory it takes:
+
+```
+pp queue add --gpu-gb 20 -- python train.py
+```
+
+It starts when one card has 20 GB free, counting what nvidia-smi reports
+and what running jobs have reserved. The job sees only that card, through
+`CUDA_VISIBLE_DEVICES`.
+
+## Queues
+
+Each queue has its own worker, limits and order. Job ids are unique across
+queues. A job with a lower `--prio` runs first, and the default is 10. A big
+job at the head of a queue is not overtaken by smaller ones.
+
+```
+pp queue add -q dl --need net=1 -- ./fetch.sh            the dl queue, taking one of a counter named net
+pp queue add --timeout 2h -- python x.py                 stopped after two hours
+pp queue add --retries 2 --retry-if 'Connection reset' -- ./sync.sh
+pp queue add --on-fail 'notify-send "job $PP_QUEUE_JOB failed"' -- ./nightly.sh
+pp queue add --tag sweep -- python x.py --lr 0.1         tagged, to act on the group later
+pp queue wait sweep                                      every job tagged sweep
+pp queue watch 12                                        a line for each start, retry and outcome
+pp queue drop 20-29                                      a range: it shows the jobs and asks first
+pp queue kill 12                                         waits while the worker stops it, then:
+                                                         killed 12 (stopped on SIGTERM)
+pp queue retry 11        pp queue hold 15        pp queue release 15
+```
+
+Limits go in `~/.config/pp/config.toml`. Every queue draws on the shared
+GPU memory, CPUs and RAM; a queue's own pool caps what it may take of them.
+A counter is a number, or a command that prints how much is free:
+
+```toml
+[resources]                  # shared by every queue
+license = 4                  # --need license=1 takes one
+nodes = { probe = "sinfo -h -t idle -o %D", every = "1m" }
+
+[queue.default]
+retries = 1
+retry_if = "Connection reset|503"
+
+[queue.dl.resources]         # only the dl queue has these
+net = 2
+```
+
+A project's `.pp.toml` can wrap every job queued from it, for example in a
+container, and add to the jobs' environment:
+
+```toml
+[queue]
+runner = "docker/run.sh"         # the job runs as docker/run.sh CMD...
+env = { HF_HUB_OFFLINE = "1" }
+```
+
+`pp queue add --no-runner` skips the runner for one job. The runner gets the
+job's environment, including `CUDA_VISIBLE_DEVICES`, and a container runner
+has to pass it in. Give a job a token or a secret with `--env` or the
+project's `env`: a variable exported in your shell reaches it only through
+the worker. `pp help queue` has the examples, and `pp help queue add` every
+option of `add`.
+
+## Working with agents
+
+An agent that starts a long job should not sit in a loop checking on it.
+With pp it runs `pp queue wait ID` in the background. Claude Code tells the
+agent when a background command exits, and the output says how the job
+ended, with the end of the log if it failed. `pp queue watch ID` prints a
+line per event instead, for a monitor. `pp queue add` prints this hint when
+an agent runs it.
+
+pp notes which session queued each job. `pp queue wait --mine` waits for
+the jobs this session queued, and also reports the ones that ended before it
+started waiting, so an outcome is not missed:
+
+```
+pp queue add -- ./train.sh       # prints the job's id, and the hint to wait in the background
+pp queue wait --mine             # every job of this session: how it ended, with the log's end on failure
+```
+
+Nothing is typed into the agent's terminal. pp leaves the session's identity
+out of the jobs it runs, so a job does not think it is inside that session.
+
+The commands follow the same rules, so an agent can use them without a
+terminal. A command that changes or deletes things shows what it will do
+and asks, unless you named each thing exactly; `-n` only shows, `-y` goes
+ahead, and without a terminal it refuses instead of asking. Lists and
+status reports have `--json`. The exit status is 0 when it worked, 1 when
+it failed and 2 when it refused; [CONTRIBUTING.md](https://github.com/xflash96/pp/blob/main/CONTRIBUTING.md#exit-status) has
+all of them.
+
+## Releases
+
+`pp promote` keeps the copy of a tool or service you use apart from the
+tree you edit. It copies a git commit into
+`~/.local/share/pp/releases/NAME/STAMP/`, runs the project's check inside
+that copy, and points the `current` link at it only if the check passes.
+The links you register go through `current`, so they never change.
+
+```toml
+# .pp.toml, at the project root
+[promote]
+check = "./test.sh"                              # must pass, or nothing changes
+links = { "~/.local/bin/notes" = "bin/notes" }
+after = "systemctl --user restart notes"         # makes the running service pick up the release
+verify = "curl -fsS http://127.0.0.1:8100/ >/dev/null"   # if this fails, pp goes back
+```
+
+```
+pp promote -n                  the plan and every problem, without changing anything
+pp promote                     release HEAD
+pp promote status              each project, its release, and how far its source is ahead
+pp promote rollback notes      back to the release before
+```
+
+`after` runs again on a rollback, so it has to work for any release. A
+database migration that cannot be undone does not belong in it. pp keeps the
+last five releases, and always keeps the current one and the one before.
+
+A systemd service runs the release by pointing at `current`:
+
+```
+ExecStart=%h/.local/share/pp/releases/notes/current/bin/serve --port 8100
+```
+
+## Everyday tools
+
+```
+pp kill :8080                  whatever listens on port 8080
+pp kill 'vite --port'          processes whose command line matches; it shows them and asks
+pp kill -n :8080               only show what it would stop
+pp kill --ports                every listening port and what owns it
+```
+
+`pkill -f PATTERN` can kill the shell that runs it, because the pattern is
+in that shell's command line. `pp kill` leaves out itself and the processes
+that started it.
+
+```
+pp batch rename ' ' '_' '*'                                  spaces to underscores, after a preview
+pp batch rename -t '{parent}_{i:03}{ext}' 'photos/**/*.jpg'   trip_001.jpg, trip_002.jpg, ... in each folder
+pp batch run 'ffmpeg -i {} {out}' '*.wav' --out 'mp3/{stem}.mp3' -j 4
+pp batch undo                                                put the last rename back
+```
+
+```
+pp http ~/notes .              a tab for each folder, at http://127.0.0.1:8000
+```
+
+`pp http` listens on 127.0.0.1 unless you pass `--bind`, and does not serve
+files such as `.env` or private keys.
+
+## Your own commands
+
+```
+pp cmd new hello --user -s "Say hello"     writes ~/.config/pp/commands/hello.py, a working start
+```
+
+A command is a Python file with a docstring and a `main` function. The
+first line of the docstring is what `pp` lists, and the rest is its help.
+Edit it into what you need. After this edit, `pp hello world` prints
+`hello, world`:
+
+```python
+"""Say hello
+
+    pp hello NAME          say hello to NAME
+"""
+from pp.lib import ui
+
+
+def main(argv: list[str]) -> int:
+    ap = ui.parser("hello", __doc__)
+    ap.add_argument("name")
+    a = ap.parse_args(argv)
+    print(f"hello, {a.name}")
+    return 0
+```
+
+Commands that someone else wrote come as a plugin: a git repository with
+command files in its `commands/` folder, or at its top.
+
+```
+pp cmd add github.com/OWNER/REPO            shows the commands it adds, then asks
+pp cmd add github.com/OWNER/REPO -n --show  only shows, with their code
+pp cmd update                               fetches, shows the diff, then asks
+pp cmd rm REPO
+pp cmd ls                                   every command, and where it comes from
+```
+
+pp clones the plugin into `~/.local/share/pp/plugins/` and checks out the
+commit you said yes to. Only `pp cmd update` moves it, after showing you
+the diff. A plugin's code runs as you, so read it before you say yes.
+
+A program named `pp-NAME` on your `PATH`, in any language, is a command
+too. To add a command to pp itself, see [CONTRIBUTING.md](https://github.com/xflash96/pp/blob/main/CONTRIBUTING.md).
+
+## Status
+
+pp is new, and its version is 0.x. A command or a config key may still
+change, and so may a field of `--json` output; the
+[changelog](https://github.com/xflash96/pp/blob/main/CHANGELOG.md) says when one does. CI runs the tests on
+Python 3.11 and 3.14, on Ubuntu 24.04.
+
+## Contributing
+
+[CONTRIBUTING.md](https://github.com/xflash96/pp/blob/main/CONTRIBUTING.md) says how to test and send a change, and
+what a command needs to fit in. Bugs go to the
+[issue tracker](https://github.com/xflash96/pp/issues).
+
+Developed with agent assistance.
+
+## License
+
+Copyright 2026 The pp Authors. Licensed under the Apache License 2.0; see
+[LICENSE](https://github.com/xflash96/pp/blob/main/LICENSE).

ppkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+pp/__init__.py,sha256=XX4APe7_X_VM5uMHXoo1OT70895_u1NJwH8vn6xdcDA,225
+pp/__main__.py,sha256=L-ldKT90Z-_Ex094d3i--sLiTs8-bLTUx2_Z0pT3acA,54
+pp/cli.py,sha256=IqLHaoxu0e1jpuJ6KXKghRCoatCRss6pnJPnRGcz_Ho,15504
+pp/commands/__init__.py,sha256=TvcAOaDdkKAefBhdC2Twgb5Uvfo578lMzMRBQHxxqq8,113
+pp/commands/batch.py,sha256=85Bg3TwkR0jH01pUWTSmn15ZaYHQATYUu9m0ViyPcIY,40754
+pp/commands/cmd.py,sha256=M8wevaPnRcO1SpBmRZ98QX2WamJ_B6Aokq8Uc86PjCo,25779
+pp/commands/completion.py,sha256=RkOUF2v4rWrzsr7TFVNHW16jRbgNEgEvWswpL1p0ocg,1637
+pp/commands/http.py,sha256=qrjfBIdGoiKuThoDE82-TnaGb36e4M3faW03v3WCYw0,77377
+pp/commands/kill.py,sha256=5yRqo6UGvxQ2yGgeNChXz45x3DlRzWCY7YYNng11hSQ,14519
+pp/commands/promote.py,sha256=UGwcV0xEaiXUCg1-V6a52QXKUg0QZLSIRw0wk-TGI7U,46507
+pp/commands/queue.py,sha256=mYtPV6xw4_fuRlCBCXTZsayBkSoyysCW1xKYFTVpcpA,15999
+pp/lib/__init__.py,sha256=MMRvvcZ3s7MSFceL_Wg8K6LirBV4HZBNLQks6khIYEQ,88
+pp/lib/config.py,sha256=PBS0rs-1hzt8gS3RE5RF62XoOzdh9-yXxGwKijbHceU,4468
+pp/lib/jobq.py,sha256=S4CNiryGlT5dCP8ckrlcQTU_2pk7jknx_au46eUlAho,162475
+pp/lib/lock.py,sha256=ZnMlDmW437V5CXKHfaZD2kXoUXgNXqa74Y2oICSDfL4,17276
+pp/lib/paths.py,sha256=kPcwlC1lCcFAlIKnw9LScjsEhKN8Hik9BOABjBid7ak,6927
+pp/lib/proc.py,sha256=ss675Vl2EXoNld-mlpLdZM2-FWvnJSE9C-cQCINe3zs,31770
+pp/lib/session.py,sha256=YY8TlbszqdDksb9wKzvuhNtgnFrgGF7d1CD9cTEpEh4,1537
+pp/lib/ui.py,sha256=hMHmFKP_ty53WG81FcFrdyOPbceANAIUkpKKazIWfeE,8154
+ppkit-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+ppkit-0.1.0.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+ppkit-0.1.0.dist-info/entry_points.txt,sha256=kCQ8mdFRBFFi3n1i8zzGzItQFX2gtRNFL8M_UqS04Ok,36
+ppkit-0.1.0.dist-info/METADATA,sha256=Wu0kUzfhzPMudCm-lJRTQWq1IEMKdTgEfUj1FmcNnX4,13634
+ppkit-0.1.0.dist-info/RECORD,,

ppkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.21
+Root-Is-Purelib: true
+Tag: py3-none-any

ppkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pp = pp.cli:main
+