paircode 0.13.2__tar.gz → 0.14.0__tar.gz

{paircode-0.13.2 → paircode-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.13.2
+Version: 0.14.0
 Summary: Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review.
 Project-URL: Homepage, https://github.com/starshipagentic/paircode
 Project-URL: Repository, https://github.com/starshipagentic/paircode

{paircode-0.13.2 → paircode-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.13.2"
+version = "0.14.0"
 description = "Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review."
 readme = "README.md"
 license = { text = "MIT" }

{paircode-0.13.2 → paircode-0.14.0}/src/paircode/__init__.py

@@ -2,4 +2,4 @@
 
 See README.md and diary/001-step-a-architecture.md for the full design.
 """
-__version__ = "0.13.1"
+__version__ = "0.14.0"

{paircode-0.13.2 → paircode-0.14.0}/src/paircode/detect.py

@@ -33,6 +33,11 @@ KNOWN_CLIS: dict[str, tuple[str, Path, str]] = {
         Path.home() / ".gemini",
         "Install Gemini CLI: `npm i -g @google/gemini-cli`",
     ),
+    "pi": (
+        "pi",
+        Path.home() / ".pi",
+        "Install Pi coding agent: `npm i -g @earendil-works/pi-coding-agent`",
+    ),
 }
 
 

{paircode-0.13.2 → paircode-0.14.0}/src/paircode/installer.py

@@ -2,6 +2,7 @@
 
 Strategy per CLI:
   - Claude Code: file-drop ~/.claude/commands/paircode.md
+  - Pi:          file-drop ~/.pi/agent/prompts/paircode.md ($@ args, bash-parallel peers)
                  Claude's native plugin-install requires publishing a marketplace;
                  overkill for one command. File-drop is first-class + documented.
   - Codex CLI:   native register via `codex marketplace add starshipagentic/paircode-codex`
@@ -80,6 +81,31 @@ def install_claude(info: CliInfo) -> InstallResult:
     )
 
 
+def install_pi(info: CliInfo) -> InstallResult:
+    """Write ~/.pi/agent/prompts/paircode.md — file-drop (native for Pi coding agent).
+
+    Pi discovers prompt templates in ~/.pi/agent/prompts/ as /name slash commands.
+    The pi variant of the template uses `$@` for arguments (Pi's convention) and
+    fires peers as parallel background bash jobs (Pi has no stock Agent tool).
+    """
+    if not info.installed:
+        return InstallResult(
+            cli_name="pi", action="skipped", path=None,
+            message=f"pi CLI not on PATH. {info.install_hint}",
+        )
+    prompts_dir = info.config_dir / "agent" / "prompts"
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+    target = prompts_dir / "paircode.md"
+    target.write_text(
+        _read_template("pi/prompts/paircode.md"),
+        encoding="utf-8",
+    )
+    return InstallResult(
+        cli_name="pi", action="installed", path=target,
+        message=f"Wrote /paircode prompt template to {prompts_dir}.",
+    )
+
+
 def _codex_already_installed() -> bool:
     """Idempotency check: is the paircode marketplace already registered?"""
     config = Path.home() / ".codex" / "config.toml"
@@ -181,6 +207,7 @@ def install_all() -> list[InstallResult]:
         "claude": install_claude,
         "codex": install_codex,
         "gemini": install_gemini,
+        "pi": install_pi,
     }
     results: list[InstallResult] = []
     for name, info in detected.items():
@@ -227,6 +254,7 @@ def uninstall_all() -> list[InstallResult]:
     claude_paths = [
         claude_home / "commands" / "paircode.md",
         claude_home / "commands" / "peerlab.md",
+        Path.home() / ".pi" / "agent" / "prompts" / "paircode.md",
         claude_home / "agents" / "paircode-peer.md",
     ]
     removed = []

paircode-0.14.0/src/paircode/templates/pi/prompts/paircode.md

@@ -0,0 +1,95 @@
+---
+description: "paircode — adversarial multi-LLM peer review. Fire peers in parallel, synthesize, write consensus to .paircode/. Usage: /paircode \"<prompt>\" [--peer id | --peers id,id]"
+---
+
+You are the **team lead** for a paircode peer-review cycle, running inside a pi session
+(alpha = you, whatever model this pi session runs). Your job: get the user a genuinely
+adversarial second opinion by firing every peer LLM in parallel, reading what they wrote,
+and synthesizing an honest consensus. All thoughts land on disk as Markdown under `.paircode/`.
+
+**$@** is the full user input after `/paircode`: a quoted prompt, optionally `--peer <id>`
+or `--peers <id,id>` filter flags.
+
+## File naming (inside every $FOCUS/{stage}/)
+- `alpha-vN.md` — your successive takes · `{peer-id}-vN.md` — each peer's takes
+- `reviews/round-N-{peer-id}-critiques-alpha.md` — peer critiques of alpha
+- `*-FINAL.md` (via `paircode converge {stage}`) · `consensus.md` — your synthesis (last write)
+
+**Reports vs code:** files in `$FOCUS/{stage}/` are always markdown reports. Code lives in
+sandboxes: peers in `.paircode/sandbox/{peer-id}/`, alpha (you) directly in the project root.
+Sandboxes are always available, never required — code only when it materially sharpens an answer.
+
+## Step 1 — Bootstrap (silent, via bash)
+```bash
+paircode ensure-scaffold
+FOCUS=$(paircode focus new "<slug-from-prompt>" --prompt "<the quoted prompt verbatim>")
+PEERS=$(paircode roster --alpha pi <user's --peer/--peers flags if any>)
+```
+Trust the roster. $FOCUS has research/ plan/ execute/ ask/ subdirs ready (each with reviews/).
+**Bootstrap discipline:** run `paircode focus new` EXACTLY ONCE and capture its stdout into $FOCUS. If you lose the value, do NOT re-run it — recover with `FOCUS=$(ls -td .paircode/focus-* | head -1)`. Strip `--peer`/`--peers` flags OUT of the text before passing the quoted prompt to `--prompt` (flags go to `paircode roster`, never into FOCUS.md).
+
+## Step 2 — Pick the flow (commit to the WHOLE flow)
+| Flow | Trigger |
+|---|---|
+| `ask` | "what do you think", "review/critique X", "second opinion" |
+| `research` | "figure out", "explore", "how should we" |
+| `research → plan` | "plan/design/lay out X" |
+| `research → plan → execute` | "build/fix/implement/ship/do" — most imperatives. **Default when ambiguous.** |
+| `execute` | "execute the plan at focus-NN" |
+
+Append `flow: <flow>` to `$FOCUS/FOCUS.md`. {stage} = first stage of {flow}.
+
+## Step 3 — Fire peers in PARALLEL (background bash, one job per peer)
+Construct a stage-appropriate peer prompt (see shapes below), then launch ALL peers at once:
+```bash
+for P in $PEERS; do
+  nohup paircode invoke "$P" "<stage-appropriate prompt>" --out "$FOCUS/{stage}/$P-v1.md" \
+    > "$FOCUS/{stage}/$P-invoke.log" 2>&1 &
+done
+wait   # blocks until every peer returns
+```
+Stage prompt shapes:
+- **research**: honest, skeptical, specific cold take on the prompt; sandbox scripts welcome to ground claims in real data; clean markdown, no preamble.
+- **plan**: concrete numbered plan (goal, scope, steps, risks, success criteria), KISS; read `../research/*-FINAL.md` if present.
+- **execute**: carry out `$FOCUS/plan/*-FINAL.md`; code/tests in your sandbox `.paircode/sandbox/{peer-id}/` only; report = what you built/ran, files, verification, open items.
+- **ask**: severity-ranked critique with file:line citations of the artifact FOCUS.md points to.
+
+## Step 4 — Alpha's own take (while peers run, before `wait` if you can)
+Write `$FOCUS/{stage}/alpha-v1.md` yourself — same stage rules. Your edge: this session's full
+context. Execute-stage asymmetry: peers code in sandboxes; you code directly in the project root
+(alpha-vN.md is the report; code lives in the repo).
+
+## Step 5 — Read everything
+After `wait`: read every `{peer-id}-v1.md` + your alpha file. Where did peers agree, clash,
+surface what you missed? Spot-check 1-2 cited claims against the actual repo.
+
+## Step 6 — Round convergence
+Quick one-shot prompt answered well in round 1 → converge. **Otherwise default to another
+round**: peers critique alpha (`reviews/round-N-{peer-id}-critiques-alpha.md` via the same
+parallel-invoke pattern), you write `alpha-v(N+1).md`, loop to Step 5. Stop when a round adds
+no new friction. No hard cap; use judgment.
+
+## Step 7 — Converge stage + consensus
+```bash
+paircode converge {stage}
+```
+Read every `*-FINAL.md`, then WRITE `$FOCUS/{stage}/consensus.md`:
+`# Consensus — {focus} — {stage}` with sections: **Where peers agreed / Where peers clashed /
+Team-lead verdict (2-3 honest paragraphs) / Next action (one concrete thing)**.
+Adversarial-but-honest. No pile-on, no rubber-stamping.
+
+## Step 8 — Advance the flow (mechanical — do NOT ask permission)
+{stage} = next stage in {flow}; jump to Step 3 (skip Steps 1-2). Previous stage's `*-FINAL.md`
+feed the next stage's prompts. The user's prompt was implicit go-ahead for the WHOLE flow;
+stop early only on a hard blocker, and say so in the final report. Last stage done → Step 9.
+
+## Step 9 — Final report (under 200 words)
+Focus path · stages+rounds run (e.g. `research (2) → plan (1) → execute (1)`) · peers that
+participated/failed · one-sentence headline from the last consensus.md.
+
+## Guardrails
+- Never skip Step 1; never invent peer commands — always `paircode invoke <id> "..." --out <path>`.
+- Fire EVERY rostered peer unless the user passed `--peer`/`--peers`.
+- Peers never touch files outside their sandbox; you never touch theirs.
+- If a peer invoke hard-fails, note it and continue with the rest — one dead peer never blocks the cycle.
+- No AI attribution in any artifact you write.