pi-goosedump 0.10.5 → 0.10.7

package/index.ts

@@ -50,6 +50,9 @@ import {
 import { Type } from '@sinclair/typebox';
 
 const require = createRequire(import.meta.url);
+const BRANCH_SUMMARY_PREFIX =
+  'The following is a summary of a branch that this conversation came back from:\n\n<summary>\n';
+const BRANCH_SUMMARY_SUFFIX = '</summary>';
 
 // One rendered message after normalizing a context into pi's native JSONL.
 interface GoosedumpMessage {
@@ -91,6 +94,7 @@ interface PiEntryJson {
   type?: string;
   id?: string;
   message?: { role?: string; content?: PiPartJson[] | string };
+  content?: PiPartJson[] | string;
   summary?: string;
 }
 
@@ -108,6 +112,15 @@ const DEFAULT_GOOSEDUMP_SETTINGS: GoosedumpSettings = {
 const TURNS_BEFORE_COMPACT_MIN = 0;
 const TURNS_BEFORE_COMPACT_MAX = 255;
 
+function isTurnsBeforeCompact(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isSafeInteger(value) &&
+    value >= TURNS_BEFORE_COMPACT_MIN &&
+    value <= TURNS_BEFORE_COMPACT_MAX
+  );
+}
+
 function piAgentDir(): string {
   return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
 }
@@ -138,7 +151,13 @@ function readJsonObject(path: string): Record<string, unknown> {
 function readJsonObjectStrict(path: string): Record<string, unknown> {
   if (!existsSync(path)) return {};
 
-  const parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${path}: ${message}`);
+  }
   if (!isRecord(parsed)) throw new Error(`${path} must contain a JSON object`);
   return parsed;
 }
@@ -165,17 +184,26 @@ function readGoosedumpSettingsFrom(path: string): Partial<GoosedumpSettings> {
 
   const settings: Partial<GoosedumpSettings> = {};
   const value = raw.turnsBeforeCompact;
-  if (
-    typeof value === 'number' &&
-    Number.isSafeInteger(value) &&
-    value >= TURNS_BEFORE_COMPACT_MIN &&
-    value <= TURNS_BEFORE_COMPACT_MAX
-  ) {
-    settings.turnsBeforeCompact = value;
-  }
+  if (isTurnsBeforeCompact(value)) settings.turnsBeforeCompact = value;
   return settings;
 }
 
+function validateGoosedumpSettings(path: string): void {
+  const root = readJsonObjectStrict(path);
+  if (root.goosedump === undefined) return;
+  if (!isRecord(root.goosedump)) {
+    throw new Error(`${path}: goosedump must be a JSON object`);
+  }
+
+  const value = root.goosedump.turnsBeforeCompact;
+  if (value !== undefined && !isTurnsBeforeCompact(value)) {
+    throw new Error(
+      `${path}: goosedump.turnsBeforeCompact must be an integer from ` +
+        `${TURNS_BEFORE_COMPACT_MIN} to ${TURNS_BEFORE_COMPACT_MAX}`,
+    );
+  }
+}
+
 function resolveGoosedumpSettings(cwd: string): GoosedumpSettings {
   return {
     ...DEFAULT_GOOSEDUMP_SETTINGS,
@@ -187,7 +215,7 @@ function resolveGoosedumpSettings(cwd: string): GoosedumpSettings {
 function notifyInvalidSettings(ctx: ExtensionContext): void {
   for (const path of [globalSettingsPath(), projectSettingsPath(ctx.cwd)]) {
     try {
-      readJsonObjectStrict(path);
+      validateGoosedumpSettings(path);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (ctx.hasUI) ctx.ui.notify(`goosedump settings error: ${message}`, 'error');
@@ -202,14 +230,7 @@ function readScopedGoosedumpSettings(cwd: string, scope: SettingsScope): Goosedu
 
   const settings: Partial<GoosedumpSettings> = {};
   const value = raw.turnsBeforeCompact;
-  if (
-    typeof value === 'number' &&
-    Number.isSafeInteger(value) &&
-    value >= TURNS_BEFORE_COMPACT_MIN &&
-    value <= TURNS_BEFORE_COMPACT_MAX
-  ) {
-    settings.turnsBeforeCompact = value;
-  }
+  if (isTurnsBeforeCompact(value)) settings.turnsBeforeCompact = value;
   return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...settings };
 }
 
@@ -250,6 +271,33 @@ function resolveGoosedumpBinary(): string {
   return require.resolve('@jarkkojs/goosedump/bin/goosedump.js');
 }
 
+function resolveNativeGoosedumpBinary(): string {
+  const target = `${process.platform}-${process.arch}`;
+  let packageName: string;
+  let binaryName = 'goosedump';
+
+  switch (target) {
+    case 'linux-x64':
+      packageName = '@jarkkojs/goosedump-linux-x64';
+      break;
+    case 'darwin-arm64':
+      packageName = '@jarkkojs/goosedump-darwin-arm64';
+      break;
+    case 'win32-x64':
+      packageName = '@jarkkojs/goosedump-win32-x64';
+      binaryName = 'goosedump.exe';
+      break;
+    default:
+      throw new Error(`unsupported platform architecture: ${target}`);
+  }
+
+  const wrapperRequire = createRequire(resolveGoosedumpBinary());
+  const packageDir = dirname(wrapperRequire.resolve(`${packageName}/package.json`));
+  const binaryPath = join(packageDir, 'bin', binaryName);
+  if (!existsSync(binaryPath)) throw new Error(`binary not found: ${binaryPath}`);
+  return binaryPath;
+}
+
 function clip(value: string, max: number): string {
   return value.length > max ? `${value.slice(0, max)}...` : value;
 }
@@ -296,11 +344,10 @@ function flattenPiContent(content: PiPartJson[] | string | undefined): string {
   return content.map(flattenPiPart).filter(Boolean).join('\n');
 }
 
-// goosedump 0.9 renders `show`/`grep`/`search` in a provider's native format.
-// Passing `--as-provider pi` normalizes every provider's output to pi's JSONL,
-// so one parser covers all sources: each `{"type":"message"}` line becomes a
-// `GoosedumpMessage` with its `content[]` parts flattened to readable text.
-function parsePiMessages(output: string): GoosedumpMessage[] {
+// goosedump renders `show`/`grep`/`search` in a provider's native format.
+// Passing `--as-provider pi` normalizes every provider's output to Pi JSONL, so
+// one parser covers all sources, including Pi-native context entries.
+export function parsePiMessages(output: string): GoosedumpMessage[] {
   const messages: GoosedumpMessage[] = [];
   for (const line of output.split('\n')) {
     if (!line) continue;
@@ -310,9 +357,22 @@ function parsePiMessages(output: string): GoosedumpMessage[] {
     } catch {
       continue;
     }
-    if (entry.type !== 'message' || !entry.message) continue;
-    const content = flattenPiContent(entry.message.content);
-    messages.push({ id: entry.id ?? '', role: entry.message.role ?? 'unknown', content });
+    if (entry.type === 'message' && entry.message) {
+      const content = flattenPiContent(entry.message.content);
+      messages.push({ id: entry.id ?? '', role: entry.message.role ?? 'unknown', content });
+    } else if (entry.type === 'custom_message') {
+      messages.push({
+        id: entry.id ?? '',
+        role: 'user',
+        content: flattenPiContent(entry.content),
+      });
+    } else if (entry.type === 'branch_summary') {
+      messages.push({
+        id: entry.id ?? '',
+        role: 'user',
+        content: `${BRANCH_SUMMARY_PREFIX}${entry.summary ?? ''}${BRANCH_SUMMARY_SUFFIX}`,
+      });
+    }
   }
   return messages;
 }
@@ -404,8 +464,8 @@ function runGoosedump(args: string[]): string {
 function runGoosedumpAsync(args: string[], signal?: AbortSignal): Promise<GoosedumpCommandOutput> {
   return new Promise((resolve, reject) => {
     execFile(
-      process.execPath,
-      [resolveGoosedumpBinary(), ...args],
+      resolveNativeGoosedumpBinary(),
+      args,
       {
         encoding: 'utf-8',
         maxBuffer: 16 * 1024 * 1024,
@@ -620,11 +680,19 @@ function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
 
 function isMessageEntry(entry: SessionEntry): entry is SessionEntry & {
   type: 'message';
-  message: { role?: string };
+  message: { role?: string; stopReason?: string };
 } {
   return entry.type === 'message';
 }
 
+function isCompletedAssistant(message: { role?: string; stopReason?: string }): boolean {
+  return (
+    message.role === 'assistant' &&
+    message.stopReason !== 'error' &&
+    message.stopReason !== 'aborted'
+  );
+}
+
 // 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']);
@@ -641,6 +709,38 @@ function piKeepRecentTokens(cwd: string): number {
   return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
 }
 
+function piCompactionEnabled(cwd: string): boolean {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.enabled === 'boolean') {
+      return compaction.enabled;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.enabled;
+}
+
+function piReserveTokens(cwd: string): number {
+  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+    const compaction = readJsonObject(path).compaction;
+    if (isRecord(compaction) && typeof compaction.reserveTokens === 'number') {
+      return compaction.reserveTokens;
+    }
+  }
+  return DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+}
+
+const SUMMARY_TOKEN_BUDGET_RATIO = 0.8;
+const OMITTED_SUMMARY_CONTEXT = '\n\n[Earlier compaction context omitted]\n\n';
+
+function piAutoCompactionPending(ctx: ExtensionContext): boolean {
+  const usage = ctx.getContextUsage();
+  if (!usage || usage.tokens === null) return false;
+
+  return (
+    piCompactionEnabled(ctx.cwd) && usage.tokens > usage.contextWindow - piReserveTokens(ctx.cwd)
+  );
+}
+
 // 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
@@ -704,7 +804,7 @@ function completedTurnsSinceCompaction(branchEntries: SessionEntry[]): number {
   let completed = 0;
   for (let i = start; i < branchEntries.length; i += 1) {
     const entry = branchEntries[i];
-    if (isMessageEntry(entry) && entry.message.role === 'assistant') completed += 1;
+    if (isMessageEntry(entry) && isCompletedAssistant(entry.message)) completed += 1;
   }
   return completed;
 }
@@ -763,12 +863,59 @@ function buildCompactRange(
     : { scope: 'lineage', until: firstKeptEntryId };
 }
 
+function utf8Prefix(text: string, maxBytes: number): string {
+  const prefix: string[] = [];
+  let bytes = 0;
+  for (const char of text) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    prefix.push(char);
+    bytes += charBytes;
+  }
+  return prefix.join('');
+}
+
+function utf8Suffix(text: string, maxBytes: number): string {
+  const suffix: string[] = [];
+  let bytes = 0;
+  for (const char of Array.from(text).reverse()) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    suffix.push(char);
+    bytes += charBytes;
+  }
+  return suffix.reverse().join('');
+}
+
+function truncateSummary(summary: string, maxBytes: number): string {
+  const text = summary.trim();
+  if (Buffer.byteLength(text) <= maxBytes) return text;
+
+  const markerBytes = Buffer.byteLength(OMITTED_SUMMARY_CONTEXT);
+  if (maxBytes <= markerBytes) return utf8Prefix(text, maxBytes);
+
+  const retainedBytes = maxBytes - markerBytes;
+  const headBytes = Math.ceil(retainedBytes / 2);
+  const tailBytes = Math.floor(retainedBytes / 2);
+  return `${utf8Prefix(text, headBytes)}${OMITTED_SUMMARY_CONTEXT}${utf8Suffix(text, tailBytes)}`;
+}
+
 function mergeCompactionSummary(
   previousSummary: string | undefined,
   generatedSummary: string,
+  reserveTokens: number,
 ): string {
+  // A token always represents at least one UTF-8 byte. Capping bytes is
+  // conservative, but unlike a chars/token estimate it cannot undercount text.
+  const maxBytes = Math.max(1, Math.floor(reserveTokens * SUMMARY_TOKEN_BUDGET_RATIO));
+  const generated = truncateSummary(generatedSummary, maxBytes);
   const previous = previousSummary?.trim();
-  return previous ? `${previous}\n\n${generatedSummary}` : generatedSummary;
+  const separator = '\n\n';
+  const generatedBytes = Buffer.byteLength(generated);
+  if (!previous || generatedBytes + Buffer.byteLength(separator) >= maxBytes) return generated;
+
+  const previousBytes = maxBytes - generatedBytes - Buffer.byteLength(separator);
+  return `${truncateSummary(previous, previousBytes)}${separator}${generated}`;
 }
 
 async function buildGoosedumpCompaction(
@@ -780,6 +927,7 @@ async function buildGoosedumpCompaction(
     fileOps: unknown;
   },
   branchEntries: SessionEntry[],
+  reserveTokens: number,
   keep?: number,
   signal?: AbortSignal,
 ): Promise<
@@ -801,7 +949,11 @@ async function buildGoosedumpCompaction(
 
   const generated = await goosedumpCompact(target, range, signal);
   if (!generated.summary) return undefined;
-  const summary = mergeCompactionSummary(preparation.previousSummary, generated.summary);
+  const summary = mergeCompactionSummary(
+    preparation.previousSummary,
+    generated.summary,
+    reserveTokens,
+  );
 
   return {
     summary,
@@ -935,11 +1087,7 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
         const projectPath = projectSettingsPath(location);
         const projectRaw = readJsonObjectStrict(projectPath).goosedump;
         const projectValue =
-          isRecord(projectRaw) &&
-          typeof projectRaw.turnsBeforeCompact === 'number' &&
-          Number.isSafeInteger(projectRaw.turnsBeforeCompact) &&
-          projectRaw.turnsBeforeCompact >= TURNS_BEFORE_COMPACT_MIN &&
-          projectRaw.turnsBeforeCompact <= TURNS_BEFORE_COMPACT_MAX
+          isRecord(projectRaw) && isTurnsBeforeCompact(projectRaw.turnsBeforeCompact)
             ? projectRaw.turnsBeforeCompact
             : undefined;
 
@@ -990,12 +1138,7 @@ async function runSettingsEditor(ctx: ExtensionContext): Promise<void> {
             }
 
             const parsed = Number(newValue);
-            if (
-              !Number.isSafeInteger(parsed) ||
-              parsed < TURNS_BEFORE_COMPACT_MIN ||
-              parsed > TURNS_BEFORE_COMPACT_MAX
-            )
-              return;
+            if (!isTurnsBeforeCompact(parsed)) return;
             try {
               writeScopedGoosedumpSetting(location, scope, key, parsed);
               settingsList.updateValue(id, newValue);
@@ -1289,6 +1432,7 @@ export function createGoosedumpIntegration(
   let turnsRemaining = 0;
   let counterTriggered = false;
   let compactionQueued = false;
+  let compactionHookActive = false;
   let pendingKeep: number | null = null;
 
   function syncCompactCounters(ctx: ExtensionContext, clearPending = false): void {
@@ -1339,7 +1483,7 @@ export function createGoosedumpIntegration(
     ctx: ExtensionContext,
     keep: number | null,
   ): 'started' | 'busy' | 'nothing-to-compact' {
-    if (compactionQueued) return 'busy';
+    if (compactionQueued || compactionHookActive) return 'busy';
     if (keep === null && !hasCompactableHistory(ctx)) return 'nothing-to-compact';
 
     compactionQueued = true;
@@ -1613,6 +1757,10 @@ export function createGoosedumpIntegration(
       if (!counterTriggered || compactionQueued) return;
       if (ctx.hasPendingMessages()) return;
       if (!hasCompactableHistory(ctx)) return;
+      // Pi checks this threshold immediately after agent_end. Let that native
+      // path invoke our session_before_compact hook instead of starting a
+      // competing manual compaction.
+      if (!resumeAfter && piAutoCompactionPending(ctx)) return;
 
       syncCompactCounters(ctx, true);
       updateStatus(ctx);
@@ -1652,7 +1800,7 @@ export function createGoosedumpIntegration(
     });
 
     pi.on('turn_end', async (event, ctx) => {
-      noteCompletedTurn(ctx);
+      if (isCompletedAssistant(event.message)) 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);
@@ -1679,12 +1827,19 @@ export function createGoosedumpIntegration(
       const target = currentSessionTarget(ctx);
       if (!target) return;
 
+      // Pi checks reserveTokens immediately after agent_end. A turn-driven
+      // ctx.compact() can reach this hook at the same time; let the first
+      // compaction proceed and cancel the duplicate before both append entries.
+      if (compactionHookActive) return { cancel: true };
+      compactionHookActive = true;
+
       try {
         const keep = pendingKeep ?? undefined;
         const compaction = await buildGoosedumpCompaction(
           target,
           event.preparation,
           event.branchEntries,
+          piReserveTokens(ctx.cwd),
           keep,
           event.signal,
         );
@@ -1708,6 +1863,7 @@ export function createGoosedumpIntegration(
         }
         return undefined;
       } finally {
+        compactionHookActive = false;
         pendingKeep = null;
       }
     });

package/package.json

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