@yusukeshib/pi-stash 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-stash
 
-A personal stash of reusable prompt fragments for the [Pi coding agent](https://pi.dev).
+A per-session stash of reusable prompt fragments for the [Pi coding agent](https://pi.dev).
 
 Jot a prompt down whenever you think of it mid-task, then pop it into the editor
 when you actually need it. Think of it as a stack-like scratchpad for prompts —
@@ -50,7 +50,20 @@ pi install npm:@yusukeshib/pi-stash
 |---------|--------|
 | `/stash <text>` | **Push** — save the given text onto the stash. |
 | `/stash` | **Pop** — pick a saved entry, insert it into the editor, and remove it from the stash. Run repeatedly to stack several fragments together. |
-| `/stash-clear` | Delete every stashed entry (with confirm). |
+| `/stash-clear` | Delete every stashed entry in this session (with confirm). |
+
+### Shortcut
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+S` | If the editor has text, **push** it onto the stash and clear the editor. If the editor is empty, **pop** a saved entry into it. |
+
+`Ctrl+S` is the one-key way to do what `/stash` does: park the prompt you're
+halfway through typing, or pull one back — without typing the command. Rebind it
+in `~/.pi/agent/keybindings.json` if it clashes with another shortcut.
+
+While the stash is non-empty, a red `stash:N` badge is shown in the footer so
+you never forget you have prompts parked.
 
 ## How it works
 
@@ -65,21 +78,13 @@ build up by hand during real work:
 
 ## Storage
 
-Entries live in a single global JSON file, **shared across every Pi session on
-the machine** (not per-project, not per-session):
-
-```
-~/.pi/agent/prompt-stash.json
-```
-
-Override the location with the `PI_STASH_PATH` environment variable:
-
-```bash
-export PI_STASH_PATH="$HOME/.config/pi/stash.json"
-```
+Entries are stored **inside the session itself** as custom session entries —
+each Pi session has its own independent stash. It survives restarts and
+`/resume`, and follows branching (`/fork`, `/clone`) correctly: a forked
+session sees the stash as it was at the fork point.
 
-> Note: the store is read-modify-written on each command. If two sessions edit
-> the stash at the exact same moment, the last write wins.
+Nothing is written outside the session file, and the stash does not
+participate in the LLM context.
 
 ## License
 

package/extensions/index.ts

@@ -1,7 +1,7 @@
 /**
- * pi-stash — a personal stash of reusable prompt fragments for the Pi coding
- * agent. Jot a prompt down whenever you think of it, then later pull up the
- * list and pop one into the editor to compose your next message.
+ * pi-stash — a per-session stash of reusable prompt fragments for the Pi
+ * coding agent. Jot a prompt down whenever you think of it, then later pull
+ * up the list and pop one into the editor to compose your next message.
  *
  * Unlike file-based prompt templates (static `/name` commands), this is an
  * ad-hoc, mutable, stack-like backlog you build up by hand during real work.
@@ -12,43 +12,31 @@
  *                  remove it from the stash. Run repeatedly to stack fragments.
  *   /stash-clear   Delete every entry (with confirm).
  *
- * Storage: a single global JSON file, shared across every Pi session on the
- * machine (not per-project, not per-session). Default location:
- *   ~/.pi/agent/prompt-stash.json
- * Override with the PI_STASH_PATH environment variable.
+ * Shortcut:
+ *   Ctrl+S         If the editor holds text, push it onto the stash (and clear
+ *                  the editor); otherwise pop a saved entry into the editor.
+ *                  A one-key way to park the prompt you're typing, or pull one
+ *                  back, without typing `/stash`.
+ *
+ * Storage: stash entries are persisted INSIDE the session itself via custom
+ * session entries (`pi.appendEntry`). Each session has its own stash, it
+ * survives restarts/resume, and it follows branching (fork/clone) correctly.
+ *
+ * While the stash is non-empty, a red badge with the entry count is shown in
+ * the footer so you don't forget about pending prompts.
  */
 
-import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 interface StashEntry {
 	text: string;
 	addedAt: number;
 }
 
-const STORE_PATH = process.env.PI_STASH_PATH || join(homedir(), ".pi", "agent", "prompt-stash.json");
+const CUSTOM_TYPE = "pi-stash-state";
+const STATUS_KEY = "pi-stash";
 const PREVIEW_LEN = 72;
 
-function load(): StashEntry[] {
-	try {
-		const raw = readFileSync(STORE_PATH, "utf8");
-		const parsed = JSON.parse(raw);
-		if (Array.isArray(parsed)) {
-			return parsed.filter((e): e is StashEntry => e && typeof e.text === "string");
-		}
-	} catch {
-		// missing or corrupt → empty stash
-	}
-	return [];
-}
-
-function save(entries: StashEntry[]): void {
-	mkdirSync(dirname(STORE_PATH), { recursive: true });
-	writeFileSync(STORE_PATH, `${JSON.stringify(entries, null, 2)}\n`, "utf8");
-}
-
 /** One-line, length-bounded preview for select menus. */
 function preview(text: string, index: number): string {
 	const oneLine = text.replace(/\s+/g, " ").trim();
@@ -58,58 +46,115 @@ function preview(text: string, index: number): string {
 }
 
 export default function (pi: ExtensionAPI) {
-	pi.registerCommand("stash", {
-		description: "Push text (with arg) or pop an entry into the editor (no arg)",
-		handler: async (args, ctx) => {
-			const text = (args ?? "").trim();
-
-			// PUSH: /stash <text>
-			if (text) {
-				const entries = load();
-				if (entries.some((e) => e.text === text)) {
-					ctx.ui.notify("Already in stash", "info");
-					return;
+	// In-memory stash for the current session; persisted as custom entries.
+	let entries: StashEntry[] = [];
+
+	function persist(): void {
+		pi.appendEntry(CUSTOM_TYPE, { entries });
+	}
+
+	/** Red, hard-to-miss footer badge while the stash is non-empty. */
+	function updateStatus(ctx: ExtensionContext): void {
+		if (entries.length > 0) {
+			// White on red background (raw ANSI so it stays red in any theme).
+			ctx.ui.setStatus(STATUS_KEY, `\x1b[41m\x1b[97m\x1b[1m stash:${entries.length} \x1b[0m`);
+		} else {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+		}
+	}
+
+	// Restore stash from the session (last persisted state on the active path).
+	pi.on("session_start", async (_event, ctx) => {
+		entries = [];
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type === "custom" && entry.customType === CUSTOM_TYPE) {
+				const data = entry.data as { entries?: unknown } | undefined;
+				if (data && Array.isArray(data.entries)) {
+					entries = data.entries.filter(
+						(e): e is StashEntry => !!e && typeof (e as StashEntry).text === "string",
+					);
 				}
-				entries.push({ text, addedAt: Date.now() });
-				save(entries);
-				ctx.ui.notify(`Stashed (${entries.length} total)`, "info");
-				return;
 			}
+		}
+		updateStatus(ctx);
+	});
 
-			// POP: /stash → pick, insert into editor, remove from stash
-			const entries = load();
-			if (entries.length === 0) {
-				ctx.ui.notify("Stash is empty. Add one with /stash <text>", "info");
+	/**
+	 * Core stash behaviour shared by the `/stash` command and the Ctrl+S
+	 * shortcut. With text → push; without text → pop into the editor.
+	 */
+	async function runStash(rawText: string, ctx: ExtensionContext): Promise<void> {
+		const text = (rawText ?? "").trim();
+
+		// PUSH: /stash <text>
+		if (text) {
+			if (entries.some((e) => e.text === text)) {
+				ctx.ui.notify("Already in stash", "info");
 				return;
 			}
-			const labels = entries.map((e, i) => preview(e.text, i));
-			const choice = await ctx.ui.select("Pop prompt:", labels);
-			if (choice === undefined) return; // cancelled / timed out
-			const idx = labels.indexOf(choice);
-			if (idx < 0) return;
-
-			const chosen = entries[idx].text;
-			const current = ctx.ui.getEditorText() ?? "";
-			const next = current.trim().length > 0 ? `${current}\n${chosen}` : chosen;
-			ctx.ui.setEditorText(next);
-
-			// pop = remove the chosen entry
-			entries.splice(idx, 1);
-			save(entries);
+			entries.push({ text, addedAt: Date.now() });
+			persist();
+			updateStatus(ctx);
+			ctx.ui.notify(`Stashed (${entries.length} total)`, "info");
+			return;
+		}
+
+		// POP: /stash → pick, insert into editor, remove from stash
+		if (entries.length === 0) {
+			ctx.ui.notify("Stash is empty. Add one with /stash <text>", "info");
+			return;
+		}
+		const labels = entries.map((e, i) => preview(e.text, i));
+		const choice = await ctx.ui.select("Pop prompt:", labels);
+		if (choice === undefined) return; // cancelled / timed out
+		const idx = labels.indexOf(choice);
+		if (idx < 0) return;
+
+		const chosen = entries[idx].text;
+		const current = ctx.ui.getEditorText() ?? "";
+		const next = current.trim().length > 0 ? `${current}\n${chosen}` : chosen;
+		ctx.ui.setEditorText(next);
+
+		// pop = remove the chosen entry
+		entries.splice(idx, 1);
+		persist();
+		updateStatus(ctx);
+	}
+
+	pi.registerCommand("stash", {
+		description: "Push text (with arg) or pop an entry into the editor (no arg)",
+		handler: async (args, ctx) => {
+			await runStash(args ?? "", ctx);
+		},
+	});
+
+	// Ctrl+S → same as bare `/stash`: pop an entry into the editor. If the
+	// editor already holds text, push it onto the stash instead.
+	pi.registerShortcut("ctrl+s", {
+		description: "Stash: push editor text, or pop a saved prompt",
+		handler: async (ctx) => {
+			const editorText = (ctx.ui.getEditorText() ?? "").trim();
+			if (editorText) {
+				ctx.ui.setEditorText("");
+				await runStash(editorText, ctx);
+			} else {
+				await runStash("", ctx);
+			}
 		},
 	});
 
 	pi.registerCommand("stash-clear", {
-		description: "Delete every stashed prompt",
+		description: "Delete every stashed prompt in this session",
 		handler: async (_args, ctx) => {
-			const entries = load();
 			if (entries.length === 0) {
 				ctx.ui.notify("Stash is already empty", "info");
 				return;
 			}
 			const ok = await ctx.ui.confirm("Clear the entire stash?", `${entries.length} entries will be deleted`);
 			if (!ok) return;
-			save([]);
+			entries = [];
+			persist();
+			updateStatus(ctx);
 			ctx.ui.notify("Stash cleared", "info");
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-stash",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "A personal stash of reusable prompt fragments for the Pi coding agent. Push prompts you think of mid-task, then pop them into the editor when you need them.",
   "type": "module",
   "license": "MIT",