@yusukeshib/pi-stash 0.1.0 → 0.2.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,10 @@ 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). |
+
+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 +68,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,25 @@
  *                  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.
+ * 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,6 +40,39 @@ function preview(text: string, index: number): string {
 }
 
 export default function (pi: ExtensionAPI) {
+	// 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",
+					);
+				}
+			}
+		}
+		updateStatus(ctx);
+	});
+
 	pi.registerCommand("stash", {
 		description: "Push text (with arg) or pop an entry into the editor (no arg)",
 		handler: async (args, ctx) => {
@@ -65,19 +80,18 @@ export default function (pi: ExtensionAPI) {
 
 			// PUSH: /stash <text>
 			if (text) {
-				const entries = load();
 				if (entries.some((e) => e.text === text)) {
 					ctx.ui.notify("Already in stash", "info");
 					return;
 				}
 				entries.push({ text, addedAt: Date.now() });
-				save(entries);
+				persist();
+				updateStatus(ctx);
 				ctx.ui.notify(`Stashed (${entries.length} total)`, "info");
 				return;
 			}
 
 			// 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");
 				return;
@@ -95,21 +109,23 @@ export default function (pi: ExtensionAPI) {
 
 			// pop = remove the chosen entry
 			entries.splice(idx, 1);
-			save(entries);
+			persist();
+			updateStatus(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.2.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",