pi-resume 1.0.0 → 1.0.2

package/README.md

@@ -8,12 +8,13 @@ Built-in `/resume` reads and parses **every line** of every session file to buil
 
 ## Solution
 
-Two commands that use `stat()` + lazy partial reads:
+Commands that use `stat()` + lazy partial reads:
 
 | Command | What it does | Speed |
 |---------|-------------|-------|
-| `/r2` | Instantly switch to the most recent session | <50ms (stat-only) |
+| `/r1` … `/r5` | Instantly switch to the N-th most recent session (`/r1` = latest) | <50ms (stat-only) |
 | `/rs` | Paginated picker: last 20, with tier navigation | <200ms first page |
+| `/rds` | Delete subagent session trees for the current project (with confirmation) | — |
 
 ## Install
 
@@ -23,9 +24,17 @@ pi install npm:pi-fast-resume
 
 ## Commands
 
-### `/r2` — Instant Resume
+### `/r1` … `/r5` — Instant Ranked Resume
 
-Switches to the most recent session (by mtime) in one step. No picker, no parsing.
+Switch to the N-th most recent session (by mtime) in one step. No picker, no parsing.
+
+- `/r1` — most recent session
+- `/r2` — 2nd most recent
+- … up to `/r5` — 5th most recent
+
+The current session is always excluded from the ranking, so `/r1` reliably jumps
+to the previous session. If fewer sessions exist than the requested rank, a
+notice is shown and nothing is switched.
 
 ### `/rs` — Smart Resume
 
@@ -47,9 +56,21 @@ Auto-escalates: if 7d is empty, jumps to 14d, then all.
 
 Config is stored in `~/.pi/agent/extensions/pi-fast-resume/config.json`.
 
+### `/rds` — Delete Subagent Sessions
+
+pi stores every subagent run under a subdirectory named like a top-level
+session (`<timestamp>_<uuid>/`), containing `<runId>/run-N/session.jsonl`.
+These accumulate on every subagent invocation and can bloat the sessions folder
+by hundreds of MB.
+
+`/rds` scans the **current project only**, shows how many trees / runs / MB
+would be freed, asks for **confirmation**, then recursively deletes just those
+subagent tree subdirectories. Your real top-level `*.jsonl` sessions (the ones
+`/r1`…`/r5` and `/rs` list) are never touched.
+
 ## How it works
 
-1. **`/r2`**: `readdir` → `stat` each `.jsonl` → sort by mtime → `switchSession(newest)`
+1. **`/r1`…`/r5`**: `readdir` → `stat` each `.jsonl` → sort by mtime → exclude current → `switchSession(others[rank-1])`
 2. **`/rs`**: Same stat scan, then read only the **first ~50 lines** of each file on the current page to extract session name and first user message
 
 No full file parsing. No `buildSessionInfo()`. No reading message content beyond the first user message.

package/extensions/index.ts

@@ -2,46 +2,111 @@
  * pi-fast-resume — fast session resume without reading all .jsonl files.
  *
  * Commands:
- *   /r2              — instantly switch to the most recent session (stat-only)
+ *   /r1 .. /r5       — instantly switch to the N-th most recent session
+ *                      (stat-only; /r1 = latest, /r5 = 5th, current excluded)
  *   /rs              — paginated session picker (last 20, "Load more", tier filter)
  *   /rs set page N   — set page size (1-50)
  *   /rs set days N   — set maxDays filter (0-30, 0 = no limit)
+ *   /rds             — delete all subagent session trees for the current project
+ *                      (asks for confirmation; top-level sessions untouched)
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { statScan, scanPage, readSessionMeta } from "../src/scanner.ts";
-import { formatEntry, truncate, sessionLabel } from "../src/format.ts";
+import {
+  statScan,
+  scanPage,
+  readSessionMeta,
+  scanSubagentTrees,
+  deleteSubagentTrees,
+} from "../src/scanner.ts";
+import { formatEntry, truncate, sessionLabel, formatSize } from "../src/format.ts";
 import { loadConfig, saveConfig } from "../src/config.ts";
 import { getSessionDir } from "../src/session-dir.ts";
 
 const DAY_TIERS = [7, 14, 0] as const;
 
+// How many ranked instant-resume commands to register: /r1 .. /rN.
+const MAX_RANK = 5;
+
+const ordinal = (n: number): string => {
+  if (n === 1) return "most recent";
+  const suffix = n === 2 ? "nd" : n === 3 ? "rd" : "th";
+  return `${n}${suffix} most recent`;
+};
+
 export default function (pi: ExtensionAPI) {
-  pi.registerCommand("r2", {
-    description: "Instantly resume the most recent session",
+  // Register /r1 .. /rN — each jumps to the rank-th most recent session
+  // (by mtime, current session excluded). /r1 = latest, /r2 = 2nd, etc.
+  for (let rank = 1; rank <= MAX_RANK; rank++) {
+    pi.registerCommand(`r${rank}`, {
+      description: `Instantly resume the ${ordinal(rank)} session`,
+      handler: async (_args: string, ctx: any) => {
+        const sessionDir = getSessionDir(ctx.cwd);
+        const files = await statScan(sessionDir);
+
+        if (files.length === 0) {
+          ctx.ui.notify("No sessions found", "error");
+          return;
+        }
+
+        const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
+        const others = files.filter((f: { file: string }) => f.file !== currentFile);
+
+        const target = others[rank - 1];
+        if (!target) {
+          ctx.ui.notify(
+            others.length === 0
+              ? "No other sessions to resume"
+              : `Only ${others.length} other session${others.length === 1 ? "" : "s"} available`,
+            "info",
+          );
+          return;
+        }
+
+        const meta = await readSessionMeta(target.file, target);
+        await ctx.switchSession(target.file, {
+          withSession: async (newCtx: any) => {
+            newCtx.ui.notify(`Resumed: ${truncate(sessionLabel(meta), 50)}`, "info");
+          },
+        });
+      },
+    });
+  }
+
+  pi.registerCommand("rds", {
+    description: "Delete subagent session trees for the current project (with confirmation)",
     handler: async (_args: string, ctx: any) => {
       const sessionDir = getSessionDir(ctx.cwd);
-      const files = await statScan(sessionDir);
+      const trees = await scanSubagentTrees(sessionDir);
 
-      if (files.length === 0) {
-        ctx.ui.notify("No sessions found", "error");
+      if (trees.length === 0) {
+        ctx.ui.notify("No subagent sessions to delete for this project", "info");
         return;
       }
 
-      const currentFile = ctx.sessionManager.getSessionFile() ?? undefined;
-      const target = files.find((f: { file: string }) => f.file !== currentFile);
+      const totalRuns = trees.reduce((s, t) => s + t.runs, 0);
+      const totalBytes = trees.reduce((s, t) => s + t.bytes, 0);
+
+      const summary =
+        `Delete ${trees.length} subagent tree${trees.length === 1 ? "" : "s"} ` +
+        `(${totalRuns} run${totalRuns === 1 ? "" : "s"}, ${formatSize(totalBytes)})?`;
+
+      const choice = await ctx.ui.select(summary, [
+        `Delete ${trees.length} tree${trees.length === 1 ? "" : "s"} (${formatSize(totalBytes)})`,
+        "Cancel",
+      ]);
 
-      if (!target) {
-        ctx.ui.notify("No other sessions to resume", "info");
+      if (!choice || choice === "Cancel") {
+        ctx.ui.notify("Cancelled — nothing deleted", "info");
         return;
       }
 
-      const meta = await readSessionMeta(target.file, target);
-      await ctx.switchSession(target.file, {
-        withSession: async (newCtx: any) => {
-          newCtx.ui.notify(`Resumed: ${truncate(sessionLabel(meta), 50)}`, "info");
-        },
-      });
+      const removed = await deleteSubagentTrees(sessionDir, trees);
+      ctx.ui.notify(
+        `Deleted ${removed}/${trees.length} subagent tree${removed === 1 ? "" : "s"} ` +
+          `(${formatSize(totalBytes)} freed)`,
+        removed === trees.length ? "info" : "error",
+      );
     },
   });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-resume",
-  "version": "1.0.0",
-  "description": "Fast session resume for pi coding agent — /r2 instant resume, /rs paginated picker",
+  "version": "1.0.2",
+  "description": "Fast session resume for pi coding agent — /r1../r5 ranked instant resume, /rs paginated picker, /rds subagent session cleanup",
   "type": "module",
   "license": "MIT",
   "keywords": [

package/src/scanner.ts

@@ -6,7 +6,7 @@
  * - First ~50 lines for header, session_info, first user message
  */
 
-import { readdir, stat } from "node:fs/promises";
+import { readdir, stat, rm } from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
 import { join } from "node:path";
@@ -165,3 +165,104 @@ export async function scanPage(
 
   return { entries, total, hasMore };
 }
+
+// A session-tree subdir is named exactly like a top-level session file, minus
+// the `.jsonl` suffix: `<ISO-timestamp>_<uuid>`. pi nests every subagent run
+// (`<runId>/run-N/session.jsonl`) under such a directory. We match that shape
+// so we never touch unrelated folders.
+const SESSION_TREE_RE = /^\d{4}-\d{2}-\d{2}T[\dZ.-]+_[0-9a-f-]{8,}$/i;
+
+export interface SubagentTree {
+  dir: string; // absolute path to the <timestamp>_<uuid> subdir
+  name: string; // the directory basename
+  runs: number; // count of run-*/session.jsonl files under it
+  bytes: number; // total size of the tree on disk
+}
+
+/**
+ * Find subagent session trees for a project dir.
+ *
+ * pi stores every subagent run under a subdirectory named like a top-level
+ * session (`<timestamp>_<uuid>/`), containing `<runId>/run-N/session.jsonl`.
+ * These accumulate fast and bloat the sessions folder. This scans ONLY the
+ * given project dir (non-recursive at the top), returning each matching
+ * subdir with its run count and on-disk size. Top-level `*.jsonl` session
+ * files (the real user sessions) are never included.
+ */
+export async function scanSubagentTrees(sessionDir: string): Promise<SubagentTree[]> {
+  let entries: string[];
+  try {
+    entries = await readdir(sessionDir, { withFileTypes: true }) as any;
+  } catch {
+    return [];
+  }
+
+  const dirs = (entries as unknown as { name: string; isDirectory: () => boolean }[])
+    .filter((e) => e.isDirectory() && SESSION_TREE_RE.test(e.name))
+    .map((e) => e.name);
+
+  const trees = await Promise.all(
+    dirs.map(async (name) => {
+      const dir = join(sessionDir, name);
+      const { runs, bytes } = await measureTree(dir);
+      return { dir, name, runs, bytes };
+    }),
+  );
+
+  // Newest first (by directory-name timestamp, which sorts lexicographically).
+  trees.sort((a, b) => (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
+  return trees;
+}
+
+/** Recursively count `session.jsonl` (run-N) files and total bytes under a dir. */
+async function measureTree(dir: string): Promise<{ runs: number; bytes: number }> {
+  let runs = 0;
+  let bytes = 0;
+
+  async function walk(d: string): Promise<void> {
+    let items: { name: string; isDirectory: () => boolean; isFile: () => boolean }[];
+    try {
+      items = (await readdir(d, { withFileTypes: true })) as any;
+    } catch {
+      return;
+    }
+    for (const it of items) {
+      const full = join(d, it.name);
+      if (it.isDirectory()) {
+        await walk(full);
+      } else if (it.isFile()) {
+        try {
+          const s = await stat(full);
+          bytes += s.size;
+          if (it.name === "session.jsonl") runs++;
+        } catch {}
+      }
+    }
+  }
+
+  await walk(dir);
+  return { runs, bytes };
+}
+
+/**
+ * Delete a list of subagent tree directories (recursively). Returns the count
+ * successfully removed. Guards against deleting anything that isn't a
+ * session-tree subdir under the given sessionDir.
+ */
+export async function deleteSubagentTrees(
+  sessionDir: string,
+  trees: SubagentTree[],
+): Promise<number> {
+  let removed = 0;
+  for (const t of trees) {
+    // Safety: the dir must live directly under sessionDir and match the shape.
+    if (join(sessionDir, t.name) !== t.dir || !SESSION_TREE_RE.test(t.name)) {
+      continue;
+    }
+    try {
+      await rm(t.dir, { recursive: true, force: true });
+      removed++;
+    } catch {}
+  }
+  return removed;
+}