pi-goosedump 0.9.3 → 0.9.5

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 {
@@ -368,6 +373,43 @@ function resolveTarget(
   return null;
 }
 
+const GOOSE_PROVIDERS = ['pi', 'claude', 'codex', 'crush', 'gemini', 'goose', 'opencode'] as const;
+
+type HistoryOperation = 'search' | 'read' | 'grep';
+
+const HISTORY_TARGET_GUIDELINE =
+  'Use the current Pi session by default; non-Pi providers require an explicit session ID.';
+
+function historyProviderParam(operation: HistoryOperation) {
+  return Type.Optional(
+    Type.Union(
+      GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)),
+      {
+        default: 'pi',
+        description: `Source provider whose sessions to ${operation}. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.`,
+      },
+    ),
+  );
+}
+
+function historySessionParam() {
+  return Type.Optional(
+    Type.String({
+      description:
+        'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
+    }),
+  );
+}
+
+function historyScopeParam() {
+  return Type.Optional(
+    Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
+      default: 'lineage',
+      description: 'Scope: lineage (current branch) or all entries in the session',
+    }),
+  );
+}
+
 async function goosedumpCompact(
   target: string,
   options: { scope?: string; from?: string; until: string },
@@ -449,6 +491,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 +687,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 +1113,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 +1134,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 {
@@ -1083,46 +1166,18 @@ export function createGoosedumpIntegration(
           label: 'goose_search',
           description:
             'Search coding agent session history by ranked relevance. Returns compact entry overviews with entry IDs; use goose_get to expand specific IDs to full content. Defaults to the current Pi session.',
-          promptSnippet:
-            'goose_search({ query, provider?, session?, scope?, page? }) - rank messages by query relevance; defaults to current Pi session',
+          promptSnippet: 'Search session history by ranked relevance',
           promptGuidelines: [
             "Use goose_search to find relevant context in this or another coding agent's session history.",
             'Start with compact ranked results, then use goose_get to expand interesting entry IDs to full content.',
             'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
-            'Omit session to search the current Pi session; set provider (e.g. "claude", "gemini") with a session id to browse another tool\'s sessions.',
+            HISTORY_TARGET_GUIDELINE,
           ],
           parameters: Type.Object({
             query: Type.String({ description: 'Search query to rank messages by relevance' }),
-            provider: Type.Optional(
-              Type.Union(
-                [
-                  Type.Literal('pi'),
-                  Type.Literal('claude'),
-                  Type.Literal('codex'),
-                  Type.Literal('crush'),
-                  Type.Literal('gemini'),
-                  Type.Literal('goose'),
-                  Type.Literal('opencode'),
-                ],
-                {
-                  default: 'pi',
-                  description:
-                    'Source provider whose sessions to search. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
-                },
-              ),
-            ),
-            session: Type.Optional(
-              Type.String({
-                description:
-                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
-              }),
-            ),
-            scope: Type.Optional(
-              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
-                default: 'lineage',
-                description: 'Scope: lineage (current branch) or all entries in the session',
-              }),
-            ),
+            provider: historyProviderParam('search'),
+            session: historySessionParam(),
+            scope: historyScopeParam(),
             page: Type.Optional(
               Type.Integer({
                 minimum: 1,
@@ -1166,47 +1221,21 @@ export function createGoosedumpIntegration(
           label: 'goose_get',
           description:
             'Expand specific entry IDs (from goose_search or goose_grep) to their full content. Defaults to the current Pi session.',
-          promptSnippet:
-            'goose_get({ ids, provider?, session? }) - expand entry IDs to full content; defaults to current Pi session',
+          promptSnippet: 'Expand session entries by ID to full content',
           promptGuidelines: [
             'Use goose_get to expand entry IDs returned by goose_search or goose_grep into their full content.',
             'Pass only the specific IDs you need; full transcripts are expensive.',
+            'Default scope is "lineage" (current branch); use scope: "all" to retrieve entries from all session branches.',
+            HISTORY_TARGET_GUIDELINE,
           ],
           parameters: Type.Object({
             ids: Type.Array(Type.String(), {
               minItems: 1,
               description: 'Entry IDs to expand (show full content)',
             }),
-            provider: Type.Optional(
-              Type.Union(
-                [
-                  Type.Literal('pi'),
-                  Type.Literal('claude'),
-                  Type.Literal('codex'),
-                  Type.Literal('crush'),
-                  Type.Literal('gemini'),
-                  Type.Literal('goose'),
-                  Type.Literal('opencode'),
-                ],
-                {
-                  default: 'pi',
-                  description:
-                    'Source provider whose sessions to read. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
-                },
-              ),
-            ),
-            session: Type.Optional(
-              Type.String({
-                description:
-                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
-              }),
-            ),
-            scope: Type.Optional(
-              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
-                default: 'lineage',
-                description: 'Scope: lineage (current branch) or all entries in the session',
-              }),
-            ),
+            provider: historyProviderParam('read'),
+            session: historySessionParam(),
+            scope: historyScopeParam(),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
             if (!goosedumpAvailable) return goosedumpUnavailableResult();
@@ -1239,45 +1268,18 @@ export function createGoosedumpIntegration(
           label: 'goose_grep',
           description:
             'Filter session messages by glob pattern (e.g. *rand*). Returns compact entry overviews with entry IDs; use goose_get to expand. Defaults to the current Pi session.',
-          promptSnippet:
-            'goose_grep({ pattern, provider?, session?, scope? }) - filter messages by glob; defaults to current Pi session',
+          promptSnippet: 'Filter session history by glob pattern',
           promptGuidelines: [
             'Use goose_grep to filter session messages by glob pattern when you need exact substring/glob matching instead of ranked relevance.',
             'Expand interesting entry IDs with goose_get.',
             'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
+            HISTORY_TARGET_GUIDELINE,
           ],
           parameters: Type.Object({
             pattern: Type.String({ description: 'Glob pattern to filter messages (e.g. *rand*)' }),
-            provider: Type.Optional(
-              Type.Union(
-                [
-                  Type.Literal('pi'),
-                  Type.Literal('claude'),
-                  Type.Literal('codex'),
-                  Type.Literal('crush'),
-                  Type.Literal('gemini'),
-                  Type.Literal('goose'),
-                  Type.Literal('opencode'),
-                ],
-                {
-                  default: 'pi',
-                  description:
-                    'Source provider whose sessions to grep. Defaults to pi. Non-pi providers have no current session, so they require an explicit session id.',
-                },
-              ),
-            ),
-            session: Type.Optional(
-              Type.String({
-                description:
-                  'Context/session ID. Defaults to the current Pi session for pi; required when provider is not pi.',
-              }),
-            ),
-            scope: Type.Optional(
-              Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
-                default: 'lineage',
-                description: 'Scope: lineage (current branch) or all entries in the session',
-              }),
-            ),
+            provider: historyProviderParam('grep'),
+            session: historySessionParam(),
+            scope: historyScopeParam(),
           }),
           async execute(_id, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
             if (!goosedumpAvailable) return goosedumpUnavailableResult();
@@ -1310,8 +1312,7 @@ export function createGoosedumpIntegration(
           label: 'goose_compact',
           description:
             "Trigger a goosedump compaction of the current session now, optionally keeping the last N user turns verbatim while summarizing everything before. Compaction runs asynchronously via Pi's compaction flow.",
-          promptSnippet:
-            "goose_compact({ keep? }) - compact now; keep last N user turns (turn-based), omit to compact up to Pi's cut",
+          promptSnippet: 'Compact session history; optionally keep recent user turns',
           promptGuidelines: [
             'Use goose_compact to compact the session proactively with goosedump when context is large or nearing limits.',
             "Pass keep:N (N >= 1) to keep the last N user turns verbatim and summarize everything before them; omit to compact up to Pi's token-based cut.",
@@ -1330,7 +1331,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 +1346,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 +1424,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 +1437,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 +1513,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.5",
   "description": "Pi extension for goosedump-backed session-history search, entry expansion, and compaction",
   "keywords": [
     "compaction",
@@ -21,13 +21,15 @@
   ],
   "type": "module",
   "scripts": {
-    "fmt": "oxfmt index.ts package.json tsconfig.json .oxfmtrc.json README.md",
-    "lint": "oxlint index.ts",
+    "fmt": "oxfmt index.ts tests package.json tsconfig.json .oxfmtrc.json README.md",
+    "lint": "oxlint index.ts tests",
     "check": "tsc --noEmit",
-    "all": "npm run fmt && npm run lint && npm run check",
-    "ci:fmt": "oxfmt --check index.ts package.json tsconfig.json .oxfmtrc.json README.md",
+    "test": "vitest run",
+    "all": "npm run fmt && npm run lint && npm run check && npm test",
+    "ci:fmt": "oxfmt --check index.ts tests package.json tsconfig.json .oxfmtrc.json README.md",
     "ci:lint": "npm run lint",
-    "ci:check": "npm run check"
+    "ci:check": "npm run check",
+    "ci:test": "npm test"
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
@@ -39,7 +41,8 @@
     "@types/node": "^24.0.0",
     "oxfmt": "^0.53.0",
     "oxlint": "^1.68.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.78.0"