@mjakl/pi-interlude 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mjakl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# pi-interlude
+
+Ever had a nice prompt prepared and the agent comes back with a question, or you need to check something before continuing? Deleting the draft is wasted effort, copy/pasting to make space for the interlude prompt is cumbersome. `zsh` has this fantastic stash command - `Esc-q` - that allows you to temporarily remove the current command and it will restore it after your interlude command is finished. `pi-interlude` brings this to pi. Install it, reload, enter something, press `Ctrl-i`, enter something else, send it, and watch with awe as your previous prompt reappears 🎉.
+
+A pi extension that lets you stash the current draft, send a one-off interlude message, and then restore the original draft.
+
+## Install
+
+### Option 1: Install from npm (recommended)
+
+```bash
+pi install npm:@mjakl/pi-interlude
+```
+
+### Option 2: Install via git
+
+```bash
+pi install git:github.com/mjakl/pi-interlude
+```
+
+### Option 3: Install local package
+
+```bash
+pi install ./
+```
+
+## What it does
+
+1. Press the interlude shortcut
+2. Your current editor text is stashed and the input box is cleared
+3. Type and send a temporary message
+4. Your previous draft is restored into the editor
+
+Press the shortcut again before sending to restore the stashed draft manually.
+
+Note: the extension currently stashes editor text only. If your draft includes attachments, those are not restored.
+
+## Default shortcuts
+
+- `f6`
+- `ctrl+i` (`i` for "interlude")
+
+`f6` is the robust default.
+`ctrl+i` is a mnemonic secondary shortcut, but in many terminals it is indistinguishable from `tab`, so it may conflict with autocomplete.
+
+## Configuration
+
+The extension reads a custom `interlude` key from pi's existing keybindings file:
+
+- `~/.pi/agent/keybindings.json`
+
+Example:
+
+```json
+{
+  "interlude": ["f6", "ctrl+i"]
+}
+```
+
+Single shortcut example:
+
+```json
+{
+  "interlude": "f6"
+}
+```
+
+If `interlude` is not set, the extension defaults to `f6` and `ctrl+i`.
+
+After changing `keybindings.json`, run `/reload` in pi.
+

package/index.ts

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+const DEFAULT_SHORTCUTS = ["f6", "ctrl+i"] as const;
+const STATUS_KEY = "interlude";
+const KEYBINDINGS_PATH = path.join(os.homedir(), ".pi", "agent", "keybindings.json");
+
+type ShortcutConfig = string | string[] | undefined;
+
+interface KeybindingsConfig {
+	interlude?: ShortcutConfig;
+	[key: string]: unknown;
+}
+
+function readKeybindings(filePath: string): KeybindingsConfig {
+	try {
+		if (!fs.existsSync(filePath)) return {};
+		const raw = fs.readFileSync(filePath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return {};
+		return parsed as KeybindingsConfig;
+	} catch {
+		return {};
+	}
+}
+
+function normalizeShortcuts(value: ShortcutConfig): string[] {
+	const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+	const normalized = values
+		.map((shortcut) => shortcut.trim().toLowerCase())
+		.filter((shortcut) => shortcut.length > 0);
+	return normalized.length > 0 ? [...new Set(normalized)] : [...DEFAULT_SHORTCUTS];
+}
+
+export default function (pi: ExtensionAPI) {
+	const keybindings = readKeybindings(KEYBINDINGS_PATH);
+	const shortcuts = normalizeShortcuts(keybindings.interlude);
+	let stashedDraft: string | null = null;
+	let armed = false;
+
+	function shortcutLabel(): string {
+		return shortcuts.join(", ");
+	}
+
+	function updateStatus(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) return;
+		if (armed && stashedDraft !== null) {
+			ctx.ui.setStatus(STATUS_KEY, `interlude armed: next sent message restores draft (${shortcutLabel()})`);
+		} else {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		}
+	}
+
+	function clearStash(ctx: ExtensionContext): void {
+		stashedDraft = null;
+		armed = false;
+		updateStatus(ctx);
+	}
+
+	function stashOrRestore(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) return;
+		const currentText = ctx.ui.getEditorText();
+
+		if (armed && stashedDraft !== null) {
+			ctx.ui.setEditorText(stashedDraft);
+			clearStash(ctx);
+			ctx.ui.notify("Interlude draft restored", "info");
+			return;
+		}
+
+		if (!currentText) {
+			ctx.ui.notify("Editor is empty, nothing to stash", "warning");
+			return;
+		}
+
+		stashedDraft = currentText;
+		armed = true;
+		ctx.ui.setEditorText("");
+		updateStatus(ctx);
+		ctx.ui.notify("Draft stashed. Send one message and your previous draft will come back.", "info");
+	}
+
+	for (const shortcut of shortcuts) {
+		// Shortcut IDs come from runtime user config, so we can't satisfy pi's KeyId
+		// string-literal type without a cast here.
+		pi.registerShortcut(shortcut as any, {
+			description: "Stash the current draft, send one interlude message, then restore the draft",
+			handler: async (ctx) => {
+				stashOrRestore(ctx);
+			},
+		});
+	}
+
+	pi.on("input", async (event, ctx) => {
+		if (!armed || stashedDraft === null) return { action: "continue" };
+		if (event.source === "extension") return { action: "continue" };
+		if (!event.text.trim()) return { action: "continue" };
+
+		const draftToRestore = stashedDraft;
+		clearStash(ctx);
+		ctx.ui.setEditorText(draftToRestore);
+		return { action: "continue" };
+	});
+
+	pi.on("before_agent_start", async (_event, ctx) => {
+		if (!armed || stashedDraft === null) return;
+		const draftToRestore = stashedDraft;
+		clearStash(ctx);
+		ctx.ui.setEditorText(draftToRestore);
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		updateStatus(ctx);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		clearStash(ctx);
+	});
+
+	pi.on("session_fork", async (_event, ctx) => {
+		clearStash(ctx);
+	});
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@mjakl/pi-interlude",
+  "version": "0.9.0",
+  "description": "Pi extension for stashing the current draft, sending an interlude message, and restoring the draft.",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "test": "node --test",
+    "check": "npm test && npm pack --dry-run >/dev/null",
+    "prepublishOnly": "npm run check"
+  },
+  "files": [
+    "index.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "interlude",
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mjakl/pi-interlude.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mjakl/pi-interlude/issues"
+  },
+  "homepage": "https://github.com/mjakl/pi-interlude#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@mariozechner/pi-agent-core": {
+      "optional": true
+    },
+    "@mariozechner/pi-coding-agent": {
+      "optional": true
+    },
+    "@mariozechner/pi-tui": {
+      "optional": true
+    },
+    "@mariozechner/pi-ai": {
+      "optional": true
+    },
+    "@sinclair/typebox": {
+      "optional": true
+    }
+  }
+}