pi-goosedump 0.9.2 → 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 {
@@ -80,6 +85,9 @@ const DEFAULT_GOOSEDUMP_SETTINGS: GoosedumpSettings = {
   turnsBeforeCompact: 0,
 };
 
+const TURNS_BEFORE_COMPACT_MIN = 0;
+const TURNS_BEFORE_COMPACT_MAX = 255;
+
 function piAgentDir(): string {
   return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
 }
@@ -113,7 +121,12 @@ function readGoosedumpSettingsFrom(path: string): Partial<GoosedumpSettings> {
 
   const settings: Partial<GoosedumpSettings> = {};
   const value = raw.turnsBeforeCompact;
-  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= 255) {
+  if (
+    typeof value === 'number' &&
+    Number.isSafeInteger(value) &&
+    value >= TURNS_BEFORE_COMPACT_MIN &&
+    value <= TURNS_BEFORE_COMPACT_MAX
+  ) {
     settings.turnsBeforeCompact = value;
   }
   return settings;
@@ -248,6 +261,13 @@ function missingSessionId(tool: string, provider = 'pi'): AgentToolResult<void>
   return textResult(`session is required for ${tool} when no current session is available`);
 }
 
+const GOOSEDUMP_UNAVAILABLE_MESSAGE =
+  'goosedump is not available. Install with: npm install @jarkkojs/goosedump';
+
+function goosedumpUnavailableResult(): AgentToolResult<void> {
+  return textResult(GOOSEDUMP_UNAVAILABLE_MESSAGE);
+}
+
 function runGoosedump(args: string[]): string {
   try {
     return execFileSync('node', [resolveGoosedumpBinary(), ...args], {
@@ -434,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.
@@ -552,29 +622,49 @@ function isControlChar(char: string): boolean {
 class NumberInputSubmenu implements Component {
   private readonly input = new Input();
   private readonly hint: (text: string) => string;
-  private readonly onSubmitValue: (value: string) => void;
+  private readonly onSubmitValue: (value: number) => void;
   private readonly onCancelEdit: () => void;
+  private readonly onInvalidValue: (message: string) => void;
   private readonly title: string;
+  private readonly currentValue: number;
+  private readonly min: number;
+  private readonly max: number;
 
   constructor(
     title: string,
-    initialValue: string,
-    onSubmit: (value: string) => void,
+    currentValue: number,
+    onSubmit: (value: number) => void,
     onCancel: () => void,
+    options?: { min?: number; max?: number; onInvalid?: (message: string) => void },
   ) {
     this.title = title;
+    this.currentValue = currentValue;
     this.onSubmitValue = onSubmit;
     this.onCancelEdit = onCancel;
-    this.input.setValue(initialValue);
+    this.onInvalidValue = options?.onInvalid ?? (() => {});
+    this.min = options?.min ?? 0;
+    this.max = options?.max ?? 255;
     this.hint = getSettingsListTheme().hint;
   }
 
   handleInput(data: string): void {
     const kb = getKeybindings();
     if (kb.matches(data, 'tui.select.confirm') || data === '\n') {
-      const digits = this.input.getValue().replace(/\D/g, '');
-      const parsed = Number(digits);
-      this.onSubmitValue(digits !== '' && Number.isSafeInteger(parsed) ? String(parsed) : '0');
+      const value = this.input.getValue();
+      if (value === '') {
+        this.onCancelEdit();
+        return;
+      }
+      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;
+      }
+      this.onSubmitValue(parsed);
       return;
     }
     if (kb.matches(data, 'tui.select.cancel')) {
@@ -593,7 +683,7 @@ class NumberInputSubmenu implements Component {
 
   render(width: number): string[] {
     return [
-      this.hint(`  ${this.title}`),
+      this.hint(`  ${this.title} · current ${this.currentValue} · ${this.min}-${this.max}`),
       '',
       ...this.input.render(width),
       '',
@@ -637,9 +727,14 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
           submenu: (currentValue, subDone) =>
             new NumberInputSubmenu(
               settingLabel(scope, 'turnsBeforeCompact'),
-              currentValue,
-              (value) => subDone(value),
+              Number(currentValue),
+              (value) => subDone(String(value)),
               () => subDone(),
+              {
+                min: TURNS_BEFORE_COMPACT_MIN,
+                max: TURNS_BEFORE_COMPACT_MAX,
+                onInvalid: (message) => ctx.ui.notify(message, 'error'),
+              },
             ),
         }));
       }
@@ -652,7 +747,12 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
           (id, newValue) => {
             const [scope, key] = id.split(':') as [SettingsScope, GoosedumpSettingKey];
             const parsed = Number(newValue);
-            if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 255) return;
+            if (
+              !Number.isSafeInteger(parsed) ||
+              parsed < TURNS_BEFORE_COMPACT_MIN ||
+              parsed > TURNS_BEFORE_COMPACT_MAX
+            )
+              return;
             writeScopedGoosedumpSetting(location, scope, key, parsed);
             settingsList.updateValue(id, newValue);
             ctx.ui.notify(`${settingLabel(scope, key)} = ${formatCompactSetting(parsed)}`, 'info');
@@ -976,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 {
@@ -1020,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 {
@@ -1091,11 +1178,7 @@ export function createGoosedumpIntegration(
             ),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
-            if (!goosedumpAvailable) {
-              return textResult(
-                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-              );
-            }
+            if (!goosedumpAvailable) return goosedumpUnavailableResult();
 
             try {
               const provider = params.provider ?? 'pi';
@@ -1172,11 +1255,7 @@ export function createGoosedumpIntegration(
             ),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
-            if (!goosedumpAvailable) {
-              return textResult(
-                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-              );
-            }
+            if (!goosedumpAvailable) return goosedumpUnavailableResult();
 
             try {
               const provider = params.provider ?? 'pi';
@@ -1247,11 +1326,7 @@ export function createGoosedumpIntegration(
             ),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
-            if (!goosedumpAvailable) {
-              return textResult(
-                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-              );
-            }
+            if (!goosedumpAvailable) return goosedumpUnavailableResult();
 
             try {
               const provider = params.provider ?? 'pi';
@@ -1298,14 +1373,14 @@ export function createGoosedumpIntegration(
             ),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
-            if (!goosedumpAvailable) {
-              return textResult(
-                'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-              );
-            }
+            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'}.`
@@ -1316,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) => {
@@ -1346,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) {
@@ -1361,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);
@@ -1390,15 +1522,13 @@ export function createGoosedumpIntegration(
       description: 'Edit goosedump compaction settings',
       handler: async (_args, ctx) => {
         if (!goosedumpAvailable) {
-          ctx.ui.notify(
-            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-            'error',
-          );
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, 'error');
           return;
         }
 
         try {
           await runSettingsEditor(ctx);
+          reloadCompactSettings(ctx.cwd);
           updateStatus(ctx);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -1411,10 +1541,7 @@ export function createGoosedumpIntegration(
       description: 'Compact now with goosedump; optionally keep the last N user turns',
       handler: async (args, ctx) => {
         if (!goosedumpAvailable) {
-          ctx.ui.notify(
-            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-            'error',
-          );
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, 'error');
           return;
         }
 
@@ -1431,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');
+        }
       },
     });
 
@@ -1439,10 +1571,7 @@ export function createGoosedumpIntegration(
       description: 'Search the current session history',
       handler: async (args, ctx) => {
         if (!goosedumpAvailable) {
-          ctx.ui.notify(
-            'goosedump is not available. Install with: npm install @jarkkojs/goosedump',
-            'error',
-          );
+          ctx.ui.notify(GOOSEDUMP_UNAVAILABLE_MESSAGE, 'error');
           return;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.9.3",
+    "@jarkkojs/goosedump": "^0.9.4",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {