pi-goosedump 0.9.3 → 0.9.4

package/index.ts

@@ -10,7 +10,12 @@ import type {
   SessionEntry,
 } from '@earendil-works/pi-coding-agent';
 
-import { defineTool, getSettingsListTheme } from '@earendil-works/pi-coding-agent';
+import {
+  DEFAULT_COMPACTION_SETTINGS,
+  defineTool,
+  findCutPoint,
+  getSettingsListTheme,
+} from '@earendil-works/pi-coding-agent';
 
 import { execFile, execFileSync } from 'node:child_process';
 import {
@@ -449,6 +454,56 @@ function isMessageEntry(entry: SessionEntry): entry is SessionEntry & {
   return entry.type === 'message';
 }
 
+// Entry types that sessionEntryToContextMessages turns into context messages;
+// only these count toward "is there anything to summarize".
+const SUMMARIZABLE_ENTRY_TYPES = new Set(['message', 'custom_message', 'branch_summary']);
+
+// Pi's compaction keepRecentTokens setting, project scope over global, matching
+// SettingsManager's merge order.
+function piKeepRecentTokens(cwd: string): number {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.keepRecentTokens === 'number') {
+      return compaction.keepRecentTokens;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
+}
+
+// Predict whether ctx.compact() would throw "Nothing to compact" or "Already
+// compacted": mirrors prepareCompaction's guards over the active lineage so
+// plugin-triggered compaction can skip the call instead of surfacing pi's
+// error toast (and needlessly aborting the agent).
+function hasCompactableHistory(ctx: ExtensionContext): boolean {
+  const branch = ctx.sessionManager.getBranch();
+  if (branch.length === 0) return false;
+  if (branch[branch.length - 1].type === 'compaction') return false;
+
+  let boundaryStart = 0;
+  for (let i = branch.length - 1; i >= 0; i -= 1) {
+    const entry = branch[i];
+    if (isCompactionEntry(entry)) {
+      const keptIndex = branch.findIndex((e) => e.id === entry.firstKeptEntryId);
+      boundaryStart = keptIndex >= 0 ? keptIndex : i + 1;
+      break;
+    }
+  }
+
+  const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd));
+  if (!branch[cut.firstKeptEntryIndex]?.id) return false;
+
+  const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
+  for (let i = boundaryStart; i < historyEnd; i += 1) {
+    if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type)) return true;
+  }
+  if (cut.isSplitTurn) {
+    for (let i = cut.turnStartIndex; i < cut.firstKeptEntryIndex; i += 1) {
+      if (SUMMARIZABLE_ENTRY_TYPES.has(branch[i].type)) return true;
+    }
+  }
+  return false;
+}
+
 // Resolution of the `keep:N` boundary: scan the active lineage from the newest
 // entry backward, count user turns (those whose message role is `user`), and
 // return the id of the Nth-from-last user entry — the earliest entry to keep.
@@ -595,12 +650,16 @@ class NumberInputSubmenu implements Component {
   handleInput(data: string): void {
     const kb = getKeybindings();
     if (kb.matches(data, 'tui.select.confirm') || data === '\n') {
-      const digits = this.input.getValue().replace(/\D/g, '');
-      if (digits === '') {
+      const value = this.input.getValue();
+      if (value === '') {
         this.onCancelEdit();
         return;
       }
-      const parsed = Number(digits);
+      if (!/^\d+$/.test(value)) {
+        this.onInvalidValue(`Enter a whole number between ${this.min} and ${this.max}`);
+        return;
+      }
+      const parsed = Number(value);
       if (!Number.isSafeInteger(parsed) || parsed < this.min || parsed > this.max) {
         this.onInvalidValue(`Enter a whole number between ${this.min} and ${this.max}`);
         return;
@@ -1017,29 +1076,6 @@ export function createGoosedumpIntegration(
       if (turnsRemaining <= 0) counterTriggered = true;
     }
     updateStatus(ctx);
-
-    if (!counterTriggered || compactionQueued) return;
-    // ctx.compact() uses manual compaction semantics and aborts the current run.
-    // Wait until no queued work remains before triggering plugin-driven compaction.
-    if (ctx.hasPendingMessages()) return;
-
-    resetCompactCounters(ctx.cwd);
-    updateStatus(ctx);
-    compactionQueued = true;
-    ctx.compact({
-      onComplete: () => {
-        compactionQueued = false;
-        resetCompactCounters(ctx.cwd);
-        updateStatus(ctx);
-      },
-      onError: (error) => {
-        compactionQueued = false;
-        resetCompactCounters(ctx.cwd);
-        updateStatus(ctx);
-        const message = error instanceof Error ? error.message : String(error);
-        if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
-      },
-    });
   }
 
   function checkGoosedump(ctx?: ExtensionContext): boolean {
@@ -1061,18 +1097,28 @@ export function createGoosedumpIntegration(
   // command and the goose_compact tool). Stashes a turn-based keep override and
   // fires Pi's compaction flow; the session_before_compact hook reads pendingKeep
   // and resets it on use, completion, or error.
-  function requestCompaction(ctx: ExtensionContext, keep: number | null): void {
+  function requestCompaction(
+    ctx: ExtensionContext,
+    keep: number | null,
+  ): 'started' | 'busy' | 'nothing-to-compact' {
+    if (compactionQueued) return 'busy';
+    if (!hasCompactableHistory(ctx)) return 'nothing-to-compact';
+
+    compactionQueued = true;
     pendingKeep = keep;
     ctx.compact({
       onComplete: () => {
+        compactionQueued = false;
         pendingKeep = null;
       },
       onError: (error) => {
+        compactionQueued = false;
         pendingKeep = null;
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
       },
     });
+    return 'started';
   }
 
   function register(pi: ExtensionAPI): void {
@@ -1330,7 +1376,11 @@ export function createGoosedumpIntegration(
             if (!goosedumpAvailable) return goosedumpUnavailableResult();
 
             const keep = params.keep ?? null;
-            requestCompaction(ctx, keep);
+            const result = requestCompaction(ctx, keep);
+            if (result === 'busy') return textResult('Compaction already in progress.');
+            if (result === 'nothing-to-compact') {
+              return textResult('Nothing to compact (session too small).');
+            }
             return textResult(
               keep !== null
                 ? `Compacting with goosedump; keeping the last ${keep} user turn${keep === 1 ? '' : 's'}.`
@@ -1341,14 +1391,62 @@ export function createGoosedumpIntegration(
       );
     }
 
+    // Fire counter-driven compaction. ctx.compact() uses manual compaction
+    // semantics and aborts the current run, so a mid-run trigger (resumeAfter)
+    // re-triggers the agent with a synthetic continue message once the
+    // compaction lands. If the session is still too small to compact, the
+    // counter stays armed and retries at a later turn_end/agent_end.
+    function maybeAutoCompact(ctx: ExtensionContext, resumeAfter: boolean): void {
+      if (!goosedumpAvailable || !shouldOverrideDefaultCompaction) return;
+      if (!counterTriggered || compactionQueued) return;
+      if (ctx.hasPendingMessages()) return;
+      if (!hasCompactableHistory(ctx)) return;
+
+      resetCompactCounters(ctx.cwd);
+      updateStatus(ctx);
+      compactionQueued = true;
+      ctx.compact({
+        onComplete: () => {
+          compactionQueued = false;
+          resetCompactCounters(ctx.cwd);
+          updateStatus(ctx);
+          if (resumeAfter && !ctx.hasPendingMessages()) {
+            pi.sendMessage(
+              {
+                customType: 'goosedump-autocompact-resume',
+                content:
+                  'The session was compacted to reduce context size. Continue the task you were working on from where you left off.',
+                display: false,
+              },
+              { triggerTurn: true },
+            );
+          }
+        },
+        onError: (error) => {
+          compactionQueued = false;
+          resetCompactCounters(ctx.cwd);
+          updateStatus(ctx);
+          const message = error instanceof Error ? error.message : String(error);
+          if (ctx.hasUI) ctx.ui.notify(`goosedump compact failed: ${message}`, 'error');
+        },
+      });
+    }
+
     pi.on('session_start', async (_event, ctx) => {
       goosedumpAvailable = checkGoosedump(ctx);
       resetCompactCounters(ctx.cwd);
       updateStatus(ctx);
     });
 
-    pi.on('turn_end', async (_event, ctx) => {
+    pi.on('turn_end', async (event, ctx) => {
       noteCompletedTurn(ctx);
+      // A turn with tool results means the agent loop would keep going; compact
+      // between turns and resume so the run's progress is not lost.
+      if (event.toolResults.length > 0) maybeAutoCompact(ctx, true);
+    });
+
+    pi.on('agent_end', async (_event, ctx) => {
+      maybeAutoCompact(ctx, false);
     });
 
     pi.on('session_before_compact', async (event, ctx) => {
@@ -1371,11 +1469,9 @@ export function createGoosedumpIntegration(
           keep,
         );
         if (compaction && 'cancel' in compaction) {
-          pendingKeep = null;
           if (ctx.hasUI) ctx.ui.notify(compaction.reason, 'info');
           return { cancel: true };
         }
-        pendingKeep = null;
         return compaction ? { compaction } : undefined;
       } catch (err) {
         if (ctx.hasUI) {
@@ -1386,15 +1482,26 @@ export function createGoosedumpIntegration(
           );
         }
         return undefined;
+      } finally {
+        pendingKeep = null;
       }
     });
 
     pi.on('session_compact', async (event, ctx) => {
-      if (!goosedumpAvailable || !event.fromExtension) return;
+      if (!goosedumpAvailable || !shouldOverrideDefaultCompaction) return;
 
-      const compactionEntry = event.compactionEntry;
-      if (!compactionEntry) return;
+      resetCompactCounters(ctx.cwd);
+      updateStatus(ctx);
 
+      const compactionEntry = event.compactionEntry;
+      if (
+        !event.fromExtension ||
+        !compactionEntry ||
+        !isRecord(compactionEntry.details) ||
+        compactionEntry.details.source !== 'goosedump'
+      ) {
+        return;
+      }
       const tokensBefore = compactionEntry.tokensBefore;
       const summaryLen = compactionEntry.summary.length;
       const tokenEstimate = Math.ceil(summaryLen / 4);
@@ -1451,7 +1558,12 @@ export function createGoosedumpIntegration(
           }
         }
 
-        requestCompaction(ctx, keep);
+        const result = requestCompaction(ctx, keep);
+        if (result === 'busy') {
+          ctx.ui.notify('Compaction already in progress', 'info');
+        } else if (result === 'nothing-to-compact') {
+          ctx.ui.notify('Nothing to compact (session too small)', 'info');
+        }
       },
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",