Pi on ¬ just serendipity 🍀

pi: block dangerous commands syntax-aware

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 28 Jul 2026 10:57:06 +0200

♠ Problem statement: block destructive shell commands issued by pi without resorting to grepping shell source with regular expressions.

My first guard was a direct port of an older hook in Claude Code:

const BLOCKED_COMMANDS: ReadonlyArray<{ pattern: RegExp; reason: string }> = [
  { pattern: /terraform\s+apply/, reason: "terraform apply is blocked - use terraform plan first" },
  { pattern: /terraform\s+destroy/, reason: "terraform destroy is blocked for safety" },
  { pattern: /git\s+reset\s+.*--hard/, reason: "git reset --hard is blocked - discards changes irreversibly" },
];

const blocked = BLOCKED_COMMANDS.find(({ pattern }) => pattern.test(command));

This matched harmless strings such as echo 'terraform destroy', while shell quoting, wrappers, substitutions, and reordered options kept opening holes. Regexes aren’t robust in this context.

Enter ASTs! Shell source could leverage a shell parser.

I switched the extension to the Bash grammar from tree-sitter-bash, loaded through the WASM Tree-sitter runtime:

await Parser.init();
const languagePath = require.resolve("tree-sitter-bash/tree-sitter-bash.wasm");
const language = await Language.load(languagePath);
return new Parser().setLanguage(language);

Tree sitter is an amazing parser.

The policy now works on executable names and arguments:

if (executable === "rm") {
  const recursive = staticArguments.some(
    (argument) => argument === "--recursive" || hasShortOption(argument, "r") || hasShortOption(argument, "R"),
  );
  const force = staticArguments.some(
    (argument) => argument === "--force" || hasShortOption(argument, "f"),
  );
  if (recursive && force) return { command, reason: "rm -rf is blocked for safety" };
}

The AST walker also follows command substitutions, heredocs, bash -c, eval, find -exec, xargs, and common wrappers. Comments and quoted data remain data. Malformed syntax and dynamic guarded arguments fail closed.

ℹ tests 48
ℹ suites 0
ℹ pass 48
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0

Local extensions do not get npm dependencies installed by Pi. I kept index.ts dependency-free: on first load it checks for the parser files, runs a pinned installation when needed, then imports the real guard.

const result = await pi.exec("npm", ["ci", "--ignore-scripts"], {
  cwd: extensionDirectory,
  timeout: 120_000,
});

const { default: dangerousCommandGuard } = await import("./guard.ts");
await dangerousCommandGuard(pi);

Finally, testing the real tool call:

% rm -rf /tmp/foo
rm -rf is blocked for safety
% test -f /tmp/foo/marker && cat /tmp/foo/marker
guard-test

The guard blocked the command; /tmp/foo/marker survived.

The source lives in my dotfiles.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pi #security

pi: asynchronous exit summaries

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 27 Jul 2026 18:18:38 +0200

♠ Problem statement: ctrl+d in pi took several seconds to quit.

The culprit was pi-memory’s session_shutdown handler. It sent one last LLM request to summarize the session, wrote its answer to the daily log, then ran qmd update. Pi awaits all shutdown handlers, correctly, so quitting waited for everything:

pi.on("session_shutdown", async (event, ctx) => {
  const result = await generateExitSummary(ctx);
  fs.writeFileSync(filePath, entry, "utf-8");
  await runQmdUpdateNow();
});

Making that promise fire-and-forget would not work: Pi exits immediately after shutdown, and either the in-flight request keeps Node alive or gets killed before it can write anything.

Instead, I made the shutdown path write a durable job, synchronously:

const job: ExitSummaryJob = {
  version: 1,
  id: randomUUID(),
  createdAt: new Date().toISOString(),
  date: todayStr(),
  reason,
  sessionId: shortSessionId(ctx.sessionManager.getSessionId()),
  conversationText: truncated.text,
  truncated: truncated.truncated,
  totalChars: truncated.totalChars,
};

const jobPath = path.join(
  EXIT_SUMMARY_JOBS_DIR,
  `${job.createdAt.replace(/[:.]/g, "-")}-${job.id}.json`,
);
fs.writeFileSync(jobPath, `${JSON.stringify(job)}\n`, { encoding: "utf-8", flag: "wx" });

The next interactive session starts an unref’ed worker. It atomically renames one job to claim it, generates summary with active model, writes it back to original day’s daily log, and deletes job. Failed jobs return to queue. A stale claimed job retries after ten minutes.

I kept upstream package intact by replacing it with a local package, effectively forking it:

% pi remove npm:pi-memory
Removed npm:pi-memory
% pi install ~/.pi/agent/local/pi-memory-async
Installed /Users/thiago.perrotta/.pi/agent/local/pi-memory-async
% pi list
User packages:
  local/pi-memory-async
    /Users/thiago.perrotta/.pi/agent/local/pi-memory-async

Jobs live in ~/.pi/agent/memory/exit-summary-jobs/. ctrl+d only writes one JSON file now; summary happens during next session, without blocking exits.

Source code: pi-memory-async.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pi #pkm

pi: update pinned npm packages

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 27 Jul 2026 14:28:59 +0200

♠ Problem statement: pin pi npm packages without giving up convenient updates.

My settings.json used to leave some package versions unpinned, until now:

     "npm:@heyhuynhgiabuu/pi-diff@0.7.6",
-    "npm:@tifan/pi-recap",
-    "npm:@tmustier/pi-tab-status",
-    "npm:@tintinweb/pi-subagents"
+    "npm:@tifan/pi-recap@0.4.4",
+    "npm:@tmustier/pi-tab-status@0.1.4",
+    "npm:@tintinweb/pi-subagents@0.14.3"

Exact versions make package installation reproducible (& safer), but Pi then does not automatically pull newer packages.

To tackle that, I added a just update-pi recipe that asks npm for each package’s current latest version and writes back an exact pin:

[doc('Update pinned Pi npm packages')]
[group('update')]
update-pi:
    #!/usr/bin/env bash
    set -euo pipefail

    settings="pi/.pi/agent/settings.json"
    updates="{}"
    while IFS= read -r spec; do
        if [[ "$spec" =~ ^npm:((@[^/]+/[^@]+)|([^@]+))(@[^@]+)?$ ]]; then
            package="${BASH_REMATCH[1]}"
        else
            echo "Invalid npm package spec: $spec" >&2
            exit 1
        fi

        latest="$(npm view "$package@latest" version)"
        pinned="npm:$package@$latest"
        updates="$(jq -cn \
            --argjson updates "$updates" \
            --arg spec "$spec" \
            --arg pinned "$pinned" \
            '$updates + {($spec): $pinned}')"
        echo "✓ $pinned"
    done < <(jq -r '.packages[] | select(type == "string" and startswith("npm:"))' "$settings")

    updated_settings="$(jq --argjson updates "$updates" \
        '.packages |= map($updates[.] // .)' "$settings")"
    printf '%s\n' "$updated_settings" > "$settings"

It handles every npm: entry, including scoped packages:

% just update-pi
✓ npm:@heyhuynhgiabuu/pi-diff@0.7.6
✓ npm:@heyhuynhgiabuu/pi-pretty@0.6.20
✓ npm:@tifan/pi-recap@0.4.4
✓ npm:@tmustier/pi-tab-status@0.1.4
✓ npm:@tintinweb/pi-subagents@0.14.3

The aggregate just update recipe invokes it alongside submodule, prek hook, and vendored-file updates.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pi #security

pi: test drive an extension

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 26 Jul 2026 01:24:35 +0200

♠ Problem statement: using pi, install an extension (package) as an one-off, without persisting it, for the sake of test-driving it, akin to pre-commit try-repo.

Solution:

% pi --help
[...]
--extension, -e <path> Load an extension file (can be used multiple times)
[...]

For example:

% pi -e npm:@tmustier/pi-usage-extension

added 1 package, and audited 2 packages in 1s

found 0 vulnerabilities

…then I can run /usage in that session.

— § —

Reply via email

#ai #dev #pi

pi: /btw side-chat

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 14:07:54 +0200

♠ Previously.

Problem statement: mid-task, I want to ask the LLM agent a quick tangential question — “will this change cause downtime?” — without polluting the main agent thread.

Claude Code has /btw¹ for exactly this. pi doesn’t, but patriceckhart/pi-btw does, as an extension. It opens a side-chat overlay: the LLM gets to see the full main thread context and answers, but nothing is written back to the conversation history.

The upstream extension imports the pre-fork @mariozechner/* package names, which are now deprecated. As such, I use earendil-works/pi. Rather than trust a diff I hadn’t read, I reimplemented it against the current API, and cross-checked against the bundled examples/extensions/summarize.ts (the canonical example for calling the model from an extension):

import { complete } from "@earendil-works/pi-ai/compat";
import type { ExtensionAPI, SessionEntry } from "@earendil-works/pi-coding-agent";
import { convertToLlm, getMarkdownTheme } from "@earendil-works/pi-coding-agent";

// ...inside the /btw command handler, once at entry:
const branch = ctx.sessionManager.getBranch();
const mainMessages = branch
  .filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
  .map((entry) => entry.message);
const mainLlmMessages = convertToLlm(mainMessages);   // frozen snapshot
const systemPrompt = ctx.getSystemPrompt();

// ...per question, the side-chat calls the model directly:
const response = await complete(
  ctx.model!,
  { systemPrompt, messages: [...mainLlmMessages, ...btwLlmMessages] },
  { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal },
);

The key move is what’s missing: the handler never calls pi.sendMessage() or appends anything. It reads the branch once, talks to the model in an ctx.ui.custom() overlay, and returns. The main session is untouched, so the next real prompt doesn’t pay for any of it.

Added to ~/.pi/agent/extensions/btw.ts.

🤖 Drafted with /bloggify.

I am no longer using Arch, btw (sad!) ↩︎

— § —

Reply via email

#ai #coding #dev #pi

pi: auto-retry stalled requests

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 13:45:41 +0200

♠ Previously.

Problem statement: sometimes a prompt in pi just hangs, as if the network dropped. It never recovers on its own — I have to hit Esc and re-prompt.

It’s 2026, this symptom should be self-recoverable.

Pi already has agent-level retry on transient errors (retry.enabled defaults to true). The catch is when it fires: a stalled connection isn’t an error until the HTTP idle timeout trips, and that defaults to five minutes:

httpIdleTimeoutMs | number | 300000 | HTTP header/body idle timeout in milliseconds […] Set to 0 to disable.

So pi would have eventually recovered. I was just quitting long before the five-minute clock ran out. Who has patience to wait for 5 minutes?!

:∴ Lower the idle timeout to O(seconds) instead:

{
  "httpIdleTimeoutMs": 30000,
  "retry": {
    "enabled": true,
    "maxRetries": 5,
    "baseDelayMs": 2000
  }
}

Dropped into ~/.pi/agent/settings.json, documented in docs/settings.md. Now a stall errors out after 30s and pi retries automatically with exponential backoff (2s, 4s, 8s…), up to five attempts. There’s no need for Esc nor re-prompting.

The idle timer resets on every byte received, so long thinking or a slow stream won’t trip it — only a genuinely dead connection will. Restart pi for the change to take effect.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pi

pi: cycle models backward with ctrl+n

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 13:23:53 +0200

♠ Previously.

Problem statement: pi binds ctrl+p to app.model.cycleForward¹ by default, but has no default binding to cycle backward other than shift+ctrl+p, which is arguably difficult to remember.

Every keybinding in pi is namespaced and overridable via ~/.pi/agent/keybindings.json, documented in docs/keybindings.md:

{
  "app.model.cycleBackward": [
    "shift+ctrl+p",
    "ctrl+n"
  ]
}

ctrl+n is also the default for app.session.toggleNamedFilter, but that only fires inside the session picker, not while a model selector or the main editor has focus.

Run /reload in pi to pick up the keybinding addition without restarting the session.

∴ ctrl+p/ctrl+n now cycle models forward/backward, matching the readline (emacs!) history bindings I already have muscle memory for.

🤖 Drafted with /bloggify.

It cycles through models selected in /scoped-models. ↩︎

— § —

Reply via email

#ai #coding #dev #pi

pi: caveman mode

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 22 Jul 2026 12:14:47 +0200

♠ Previously, previously.

Problem statement: adopt caveman in pi.

Pi isn’t one of the 30+ agents caveman auto-detects. The install matrix (INSTALL.md) lists agent detection rules one by one — claude, cursor, windsurf, opencode, openclaw, etc — and pi isn’t in it. Running the one-liner installer here would just skip everything silently. Booo!

Rather than run someone else’s curl | bash against an agent it wasn’t built for, “““I””” reimplemented the terse-speak part natively, since pi already ships the two primitives needed: skills and extensions.

A skill for /skill:caveman documentation, and an extension that rewrites the system prompt on every turn via pi.on("before_agent_start", (event) => ...):

const INSTRUCTIONS = `Caveman mode: on. Respond terse. Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging. Fragments OK. Short synonyms. Technical terms exact. Pattern: [thing] [action] [reason]. [next step]. Example — not: "Sure! I'd be happy to help you with that." yes: "Bug in auth middleware. Fix:"
Boundaries, always: code blocks, commit messages, and PR descriptions stay normal full verbosity, never compressed. Drop caveman style for security warnings, irreversible/destructive actions, or when the user seems confused — resume caveman after.`;

export default function (pi: ExtensionAPI) {
  let on = true; // auto-on by default, every session

  const applyStatus = (ctx: { ui: { setStatus: (k: string, v?: string) => void } }) => {
    ctx.ui.setStatus("caveman", on ? "[caveman]" : undefined);
  };

  pi.on("session_start", async (_event, ctx) => applyStatus(ctx));

  pi.on("before_agent_start", (event) => {
    if (!on) return;
    return { systemPrompt: `${event.systemPrompt}\n\n${INSTRUCTIONS}` };
  });

  pi.registerCommand("caveman", {
    description: "Toggle caveman terse-response mode: on|off (default: on)",
    handler: async (args, ctx) => {
      const arg = args.trim().toLowerCase();
      if (arg === "off" || arg === "stop" || arg === "normal") on = false;
      else if (arg === "on" || arg === "") on = true;
      else return ctx.ui.notify(`Unknown arg "${arg}". Use: on | off`, "error");
      applyStatus(ctx);
      ctx.ui.notify(on ? "Caveman mode on." : "Caveman mode off.", "info");
    },
  });
}

before_agent_start fires on every prompt, before the agent loop starts, so the instructions are re-appended each turn instead of relying on one message that could get pruned from context. Dropped in ~/.pi/agent/extensions/caveman.ts, auto-discovered, no /reload needed after the first load.

Unlike the Claude Code plugin, I skipped lite/full/ultra/wenyan — I called that bloat back in June, and I’m not adding it to my own version either. On or off is enough.

The result, unprompted:

user: caveman on or off now?

assistant: Caveman: on.

user: how to turn it off?

assistant: /caveman off

I also skipped the parts that don’t have a pi equivalent: the statusline savings counter, /caveman-stats, the caveman-shrink MCP proxy that rewrites tool descriptions (a proxy that rewrites what an agent sees is exactly the kind of thing worth reading before installing). The 40-line extension above covers what I actually wanted.

One rule baked into both the skill and the extension: code, commits, and PRs stay full verbosity, never compressed.

This experience was an eye-opener for me to realize how bloated the upstream caveman project became.

🤖 Drafted with /bloggify.

— § —

Reply via email

#ai #coding #dev #pi

★ Oneshot prompting

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 03 Jan 2026 16:35:28 -0300

♠ I just wrote this post about neovim and git hunks.

In it I mentioned various git repositories, but did not link to them whilst writing the post. Ah, these lazy engineers.

Why not ask the LLM to link to them for me, especially because they are popular projects? Then I had the idea to try to do it without opening an interactive coding agent as I’m used to (think of Claude Code, OpenAI Codex, Amp Code, Open Code).

Amp Code:

% amp -x "add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md"
Error: Insufficient credit balance.

% amp --mode free -x "add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md"
Error: Execute mode is not permitted with --mode 'free'

Oh. Okay.

Pi + Gemini 3 Pro Preview:

% pi -p "add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md"
I have added the requested GitHub repository links for the Git TUIs (gitui, tig, lazygit) in the blog post `content/posts/2026-01-03-neovim-inline-git-hunk-control.md`.

Here are the changes made:
- `gitui` -> `[gitui](https://github.com/extrawurst/gitui)`
- `tig` -> `[tig](https://github.com/jonas/tig)`
- `lazygit` -> `[lazygit](https://github.com/jesseduffield/lazygit)`

Great job! Let’s git stash it and try again with other agents I use, for the sake of completeness. I’ll use the same prompt.

Claude Code + Sonnet 4.5:

% claude -p 'add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md'
I need your permission to edit the file `content/posts/2026-01-03-neovim-inline-git-hunk-control.md` to add GitHub repository links to the git TUIs (gitui, tig, and lazygit).

claude --dangerously-skip-permissions -p 'add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md'
Perfect! I've added GitHub repository links to all three git TUIs mentioned in the post:

1. **gitui** → https://github.com/extrawurst/gitui
2. **tig** → https://github.com/jonas/tig
3. **lazygit** → https://github.com/jesseduffield/lazygit

The links are now properly formatted as Markdown links in the post at `content/posts/2026-01-03-neovim-inline-git-hunk-control.md:52-54`.

OpenAI Codex + GPT 5.1 Codex Max:

% codex exec "add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md"
[...lots of output...]
-- **gitui**
-- tig
-- lazygit
+- **[gitui](https://github.com/extrawurst/gitui)**
+- [tig](https://github.com/jonas/tig)
+- [lazygit](https://github.com/jesseduffield/lazygit)

 ...or graphically with IDEs with as VSCode.


tokens used
7,432
- Added GitHub repository links for gitui, tig, and lazygit in `content/posts/2026-01-03-neovim-inline-git-hunk-control.md` so readers can jump to each TUI.
- No tests run (doc-only change).

Open Code + GLM 4.7 Free:

% opencode --model opencode/glm-4.7-free run "add github repository links to git tuis in this post: @content/posts/2026-01-03-neovim-inline-git-hunk-control.md"
|  Read     content/posts/2026-01-03-neovim-inline-git-hunk-control.md
|  Search   Web search: tig git tui github repository
|  Search   Web search: gitui github repository
|  Search   Web search: lazygit github repository
|  Edit     content/posts/2026-01-03-neovim-inline-git-hunk-control.md

Done. Added GitHub links for gitui, tig, and lazygit to the post.

% git --no-pager diff
diff --git content/posts/2026-01-03-neovim-inline-git-hunk-control.md content/posts/2026-01-03-neovim-inline-git-hunk-control.md
index 1a6465f3b..3324a71c7 100644
--- content/posts/2026-01-03-neovim-inline-git-hunk-control.md
+++ content/posts/2026-01-03-neovim-inline-git-hunk-control.md
@@ -49,9 +49,9 @@ What now>

 It's also possible to manage hunks via git TUIs (=from the terminal) such as:

-- **gitui**
-- tig
-- lazygit
+- **[gitui](https://github.com/gitui-org/gitui)**
+- [tig](https://github.com/jonas/tig)
+- [lazygit](https://github.com/jesseduffield/lazygit)

 ...or graphically with IDEs with as VSCode.

Guess which one is my favorite for simple tasks?

— § —

Reply via email

#ai #bestof #dev #pi

★ Pi

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 23 Dec 2025 11:45:10 -0300

♠ Mario Zechner’s pi (via Peter Steinberger):

Mario Zechner’s pi is currently the gold-standard for differential rendering, while also using all tricks of modern terminals — including showing inline images:

This paragraph was enough to entice my curiosity to try it out.

https://shittycodingagent.ai/:

There are many shitty coding agents, but this one is mine.

Features

Minimal. Opinionated. Extensible.

Lean core keeps your context clean. Use only what you need.

This was love at first sight.

Sounds familiar?

I love its philosophy:

What we didn’t build

pi is opinionated about what it won’t do. These are intentional design decisions to minimize context bloat and avoid anti-patterns.

— No MCP. Build CLI tools with READMEs (see Skills). The agent reads them on demand. Would you like to know more? If you must, use mcporter. — No sub-agents. Spawn pi instances via tmux, or build your own sub-agent tool. Observability and steerability for you and the agent. — No permission popups. Security theater. Run in a container or build your own with Hooks. — No plan mode. Gather context in one session, write plans to file, start fresh for implementation. — No built-in to-dos. They confuse models. Use a TODO.md file, or build your own with custom tools. — No background bash. Use tmux. Full observability, direct interaction.

The full rationale is in the blog post, which is a very recommended read.

We need more of this. It is currently one of my favorite CLI agents, alongside Claude Code (the golden standard) and Amp Code.

Note that pi is model agnostic, comparable to OpenCode.

— § —

Reply via email

#bestof #dev #pi #serenity