pi-goosedump 0.1.4 → 0.2.2

package/README.md

@@ -20,19 +20,19 @@ Once installed, pi-goosedump registers a tool and a slash command:
 
 The agent can browse session history with:
 
-| Action   | Description                                |
-| -------- | ------------------------------------------ |
-| `list`   | List all available sessions                |
-| `search` | Search within a session with regex pattern |
-| `expand` | Show full content for specific entry IDs   |
-| `view`   | View the full session transcript           |
+| Action   | Description                              |
+| -------- | ---------------------------------------- |
+| `list`   | List all available sessions              |
+| `search` | Rank messages by query relevance         |
+| `expand` | Show full content for specific entry IDs |
+| `view`   | View the full session transcript         |
 
 Examples:
 
 ```
 goosedump({ action: "list" })
 goosedump({ action: "search", contextId: "abc123", query: "bug fix" })
-goosedump({ action: "expand", contextId: "abc123", ids: [0, 3, 5] })
+goosedump({ action: "expand", contextId: "abc123", ids: ["entry-a", "entry-b"] })
 goosedump({ action: "view", contextId: "abc123" })
 ```
 
@@ -40,6 +40,13 @@ goosedump({ action: "view", contextId: "abc123" })
 
 Opens an interactive session browser.
 
+### Compaction
+
+pi-goosedump hooks Pi's `/compact` and auto-compaction flow. It uses
+`goosedump compact pi <session>` with Pi's compaction range (`--from`,
+`--until`, and `--scope`) so the generated summary matches the entries Pi is
+about to replace.
+
 ## License
 
 `pi-goosedump` is licensed under `MIT`. See [LICENSE](LICENSE) for more

package/index.ts

@@ -3,21 +3,27 @@
 
 import type {
   AgentToolResult,
+  CompactionEntry,
+  CompactionResult,
   ExtensionAPI,
   ExtensionContext,
+  SessionEntry,
 } from '@earendil-works/pi-coding-agent';
 
 import { defineTool } from '@earendil-works/pi-coding-agent';
 
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 
 import { Key, matchesKey, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
 
-const GOOSEDUMP_VERSION = [0, 1, 4] as const;
+const require = createRequire(import.meta.url);
+
+const GOOSEDUMP_VERSION = [0, 2, 2] as const;
 
 interface GoosedumpListing {
   id: string;
@@ -160,10 +166,26 @@ function formatMessagesFull(messages: GoosedumpMessage[]): string {
   return messages.map((m) => `[${m.id}] ${m.role}:\n${m.content}`).join('\n\n---\n\n');
 }
 
-function goosedumpList(): GoosedumpListing[] {
-  const output = execFileSync(process.execPath, [binaryPath(), 'pi'], {
+function runGoosedump(args: string[]): string {
+  return execFileSync(process.execPath, [binaryPath(), ...args], {
     encoding: 'utf-8',
   });
+}
+
+function parsePageInfo(output: string, fallbackPage: number): { page: number; totalPages: number } {
+  const match = output.match(/\(page\s+(\d+)\s+of\s+(\d+)\):/i);
+  if (!match) {
+    return { page: fallbackPage, totalPages: 1 };
+  }
+
+  return {
+    page: Number(match[1]),
+    totalPages: Number(match[2]),
+  };
+}
+
+function goosedumpList(): GoosedumpListing[] {
+  const output = runGoosedump(['list', 'pi']);
   return parseListings(output);
 }
 
@@ -178,37 +200,34 @@ function goosedumpContext(
     page?: number;
   } = {},
 ): GoosedumpContextResult {
-  const args = ['pi', contextId];
+  const scope = options.scope ?? 'lineage';
+  const hasQuery = typeof options.grep === 'string';
+  const args = hasQuery
+    ? options.rank === false
+      ? ['grep', 'pi', contextId, options.grep ?? '']
+      : ['search', 'pi', contextId, options.grep ?? '']
+    : ['show', 'pi', contextId];
 
-  if (options.scope && options.scope !== 'lineage') {
-    args.push('--scope', options.scope);
-  }
-  if (options.grep) {
-    args.push('--grep', options.grep);
-  }
   if (options.compact) {
-    args.push('--compact');
+    args.push('--clip');
   }
   if (options.ids) {
     args.push('--ids', options.ids);
   }
-  if (options.rank && options.grep) {
-    args.push('--rank');
-    if (options.page && options.page > 1) {
-      args.push('--page', String(options.page));
-    }
+  if (hasQuery && options.rank !== false && options.page) {
+    args.push('--page', String(options.page));
   }
+  args.push('--scope', scope);
 
-  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
-    encoding: 'utf-8',
-  });
-
+  const output = runGoosedump(args);
   const messages = parseMessages(output);
+  const pageInfo = parsePageInfo(output, options.page ?? 1);
+
   return {
     messages,
     totalCount: messages.length,
-    page: options.page ?? 1,
-    totalPages: 1,
+    page: pageInfo.page,
+    totalPages: pageInfo.totalPages,
   };
 }
 
@@ -217,17 +236,40 @@ function goosedumpExpand(
   entryIds: string[],
   scope: string = 'lineage',
 ): GoosedumpMessage[] {
-  const ids = entryIds.join(',');
-  const args = ['pi', contextId, '--ids', ids];
-  if (scope !== 'lineage') {
-    args.push('--scope', scope);
-  }
+  if (entryIds.length === 0) return [];
+
+  const output = runGoosedump([
+    'show',
+    'pi',
+    contextId,
+    '--ids',
+    entryIds.join(','),
+    '--scope',
+    scope,
+  ]);
+  return parseMessages(output);
+}
 
-  const output = execFileSync(process.execPath, [binaryPath(), ...args], {
-    encoding: 'utf-8',
-  });
+function goosedumpCompact(
+  contextId: string,
+  options: {
+    scope?: string;
+    from?: string;
+    until?: string;
+    ids?: string[];
+  },
+): string {
+  const scope = options.scope ?? 'lineage';
+  const args = ['compact', 'pi', contextId, '--scope', scope];
+
+  if (options.ids && options.ids.length > 0) {
+    args.push('--ids', options.ids.join(','));
+  } else {
+    if (options.from) args.push('--from', options.from);
+    if (options.until) args.push('--until', options.until);
+  }
 
-  return parseMessages(output);
+  return runGoosedump(args).trim();
 }
 
 export interface GoosedumpIntegrationOptions {
@@ -235,18 +277,23 @@ export interface GoosedumpIntegrationOptions {
   overrideDefaultCompaction?: boolean;
 }
 
-interface MessageLike {
-  role?: string;
-  content?: string | { type: string; text?: string; source?: unknown }[];
+interface GoosedumpCompactRange {
+  scope: string;
+  from?: string;
+  until: string;
+  ids?: string[];
 }
 
-interface ExtractedContext {
-  goal: string;
-  outstanding: string[];
-  references: string[];
-  decisions: string[];
-  constraints: string[];
-  status: string;
+interface GoosedumpCompactionDetails {
+  source: 'goosedump';
+  goosedumpVersion: string | null;
+  contextId: string;
+  scope: string;
+  from?: string;
+  until?: string;
+  ids?: string[];
+  previousSummaryIncluded: boolean;
+  fileOps: unknown;
 }
 
 export interface GoosedumpIntegration {
@@ -257,143 +304,138 @@ export default function (pi: ExtensionAPI) {
   createGoosedumpIntegration().register(pi);
 }
 
-function getMessageText(m: MessageLike): string {
-  if (typeof m.content === 'string') return m.content;
-  if (Array.isArray(m.content)) {
-    return m.content
-      .filter((c) => c.type === 'text' && typeof c.text === 'string')
-      .map((c) => c.text!)
-      .join(' ');
-  }
-  return '';
-}
-
-function extractContextFromMessages(messages: MessageLike[]): ExtractedContext {
-  const goalPatterns = [
-    /(?:goal|objective|task|aim|purpose)[\s:]*([^.\n]+)/gi,
-    /(?:working on|implementing|building|creating|fixing|adding)\s+([^.\n]+)/gi,
-    /#\s*(?:Goal|Task|Objective)[\s:]*([^\n]+)/gi,
-  ];
-
-  const referencePatterns = [
-    /(?:https?:\/\/[^\s]+)/gi,
-    /(?:[\w./-]+\/[@\w.-]+(?:#\S+)?)/g,
-    /(?:`[^`]+\.[a-z]{1,6}`)/g,
-    /(?:v?\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)/g,
-    /(?:#[1-9]\d*)/g,
-  ];
-
-  const decisionPatterns = [
-    /(?:decided|decision|chosen?|opted|settled|agreed)\s+(?:to\s+)?([^.\n]+)/gi,
-    /(?:will|should|must|going to)\s+(?:use|switch|change|keep|stay|go with)\s+([^.\n]+)/gi,
-    /(?:let's|lets|we'll)\s+([^.\n]+)/gi,
-  ];
-
-  const constraintPatterns = [
-    /(?:cannot|can't|must not|should not|don't|do not|never)\s+([^.\n]+)/gi,
-    /(?:constraint|restriction|limitation|requirement)[\s:]*([^.\n]+)/gi,
-    /(?:need to|have to|required to)\s+(?:keep|maintain|preserve|ensure|avoid)\s+([^.\n]+)/gi,
-  ];
-
-  const statusPatterns = [
-    /(?:status|state|progress)[\s:]*([^.\n]+)/gi,
-    /(?:done|completed|finished|resolved|fixed)\s+([^.\n]+)/gi,
-    /(?:todo|pending|remaining|left|in progress|wip)\s*:?\s*([^.\n]+)/gi,
-  ];
-
-  const allText = messages.map((m) => getMessageText(m)).join('\n');
-
-  const recentText = messages
-    .slice(-30)
-    .map((m) => getMessageText(m))
-    .join('\n');
-
-  const extractMatches = (text: string, patterns: RegExp[]): Set<string> => {
-    const matches = new Set<string>();
-    for (const pattern of patterns) {
-      pattern.lastIndex = 0;
-      let match: RegExpExecArray | null;
-      while ((match = pattern.exec(text)) !== null) {
-        const extracted = (match[1] ?? '').trim().slice(0, 200);
-        if (extracted.length > 3) matches.add(extracted);
-      }
-    }
-    return matches;
-  };
+function sessionFileContextId(sessionFile: string | null | undefined): string | null {
+  if (!sessionFile) return null;
 
-  const goalMatches = extractMatches(allText, goalPatterns);
-  const goal = goalMatches.size > 0 ? [...goalMatches][0] : 'Ongoing development work';
+  const name = basename(sessionFile);
+  const nameMatch = name.match(
+    /(?:^|_)([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i,
+  );
+  if (nameMatch) return nameMatch[1];
 
-  const outstandingItems = messages
-    .filter((m: MessageLike) => {
-      const text = getMessageText(m);
-      return /todo|pending|remaining|left|wip|bug|issue|fixme/gi.test(text);
-    })
-    .slice(-10)
-    .map((m: MessageLike) => {
-      const content = getMessageText(m);
-      const lines = content.split('\n').filter((l: string) => l.trim().length > 10);
-      return lines.length > 0 ? lines[0].trim().slice(0, 120) : null;
-    })
-    .filter((l: string | null): l is string => l !== null)
-    .slice(0, 8);
+  try {
+    const firstLine = readFileSync(sessionFile, 'utf-8').split(/\r?\n/, 1)[0];
+    const header = JSON.parse(firstLine) as { id?: unknown };
+    return typeof header.id === 'string' && header.id.length > 0 ? header.id : null;
+  } catch {
+    return null;
+  }
+}
 
-  const referenceMatches = extractMatches(allText, referencePatterns);
-  const references = [...referenceMatches].slice(0, 15);
+function currentSessionContextId(ctx: ExtensionContext): string | null {
+  return sessionFileContextId(ctx.sessionManager.getSessionFile());
+}
 
-  const decisionMatches = extractMatches(recentText, decisionPatterns);
-  const decisions = [...decisionMatches].slice(0, 6);
+function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
+  return entry.type === 'compaction';
+}
 
-  const constraintMatches = extractMatches(allText, constraintPatterns);
-  const constraints = [...constraintMatches].slice(0, 6);
+function latestCompactionBefore(
+  branchEntries: SessionEntry[],
+  untilIndex: number,
+): CompactionEntry | undefined {
+  for (let i = untilIndex - 1; i >= 0; i -= 1) {
+    const entry = branchEntries[i];
+    if (isCompactionEntry(entry)) return entry;
+  }
+  return undefined;
+}
 
-  const statusMatches = extractMatches(recentText, statusPatterns);
-  const status = statusMatches.size > 0 ? [...statusMatches][0] : 'In progress';
+function compactionStartId(
+  branchEntries: SessionEntry[],
+  previousCompaction: CompactionEntry,
+  untilIndex: number,
+): string | undefined {
+  const keptIndex = branchEntries.findIndex(
+    (entry) => entry.id === previousCompaction.firstKeptEntryId,
+  );
+  if (keptIndex >= 0 && keptIndex < untilIndex) return previousCompaction.firstKeptEntryId;
+
+  const compactionIndex = branchEntries.findIndex((entry) => entry.id === previousCompaction.id);
+  if (compactionIndex >= 0 && compactionIndex + 1 < untilIndex) {
+    return branchEntries[compactionIndex + 1].id;
+  }
 
-  return {
-    goal,
-    outstanding:
-      outstandingItems.length > 0 ? outstandingItems : ['No outstanding items identified'],
-    references,
-    decisions,
-    constraints: constraints.length > 0 ? constraints : ['No specific constraints identified'],
-    status,
-  };
+  return undefined;
 }
 
-function formatCompactionSummary(ctx: ExtractedContext): string {
-  const sections: string[] = [];
-
-  sections.push(`## Session Goal\n${ctx.goal}`);
+function buildCompactRange(
+  branchEntries: SessionEntry[],
+  firstKeptEntryId: string,
+): GoosedumpCompactRange | undefined {
+  const untilIndex = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+  if (untilIndex < 0) return undefined;
+
+  const previousCompaction = latestCompactionBefore(branchEntries, untilIndex);
+  const from = previousCompaction
+    ? compactionStartId(branchEntries, previousCompaction, untilIndex)
+    : undefined;
+
+  return from && from !== firstKeptEntryId
+    ? { scope: 'lineage', from, until: firstKeptEntryId }
+    : { scope: 'lineage', until: firstKeptEntryId };
+}
 
-  if (ctx.status) {
-    sections.push(`## Status\n${ctx.status}`);
-  }
+function mergeWithPreviousSummary(
+  summary: string,
+  previousSummary: string | undefined,
+): { summary: string; previousSummaryIncluded: boolean } {
+  const nextSummary = summary.trim();
+  const priorSummary = previousSummary?.trim();
 
-  if (ctx.outstanding.length > 0) {
-    sections.push(`## Outstanding Context\n${ctx.outstanding.map((o) => `- ${o}`).join('\n')}`);
+  if (!priorSummary) {
+    return { summary: nextSummary, previousSummaryIncluded: false };
   }
-
-  if (ctx.decisions.length > 0) {
-    sections.push(`## Key Decisions\n${ctx.decisions.map((d) => `- ${d}`).join('\n')}`);
+  if (!nextSummary) {
+    return { summary: priorSummary, previousSummaryIncluded: true };
   }
 
-  if (ctx.constraints.length > 0) {
-    sections.push(`## Constraints\n${ctx.constraints.map((c) => `- ${c}`).join('\n')}`);
-  }
+  return {
+    summary: `${priorSummary}\n\n## Recent Compaction Update\n${nextSummary}`,
+    previousSummaryIncluded: true,
+  };
+}
 
-  if (ctx.references.length > 0) {
-    sections.push(`## References\n${ctx.references.map((r) => `- ${r}`).join('\n')}`);
-  }
+function buildGoosedumpCompaction(
+  contextId: string,
+  preparation: {
+    firstKeptEntryId: string;
+    tokensBefore: number;
+    previousSummary?: string;
+    fileOps: unknown;
+  },
+  branchEntries: SessionEntry[],
+): CompactionResult<GoosedumpCompactionDetails> | undefined {
+  const range = buildCompactRange(branchEntries, preparation.firstKeptEntryId);
+  if (!range) return undefined;
+
+  const summary = goosedumpCompact(contextId, range);
+  const merged = mergeWithPreviousSummary(summary, preparation.previousSummary);
+  if (!merged.summary) return undefined;
 
-  return sections.join('\n\n');
+  return {
+    summary: merged.summary,
+    firstKeptEntryId: preparation.firstKeptEntryId,
+    tokensBefore: preparation.tokensBefore,
+    details: {
+      source: 'goosedump',
+      goosedumpVersion: goosedumpVersion(),
+      contextId,
+      scope: range.scope,
+      from: range.from,
+      until: range.until,
+      ids: range.ids,
+      previousSummaryIncluded: merged.previousSummaryIncluded,
+      fileOps: preparation.fileOps,
+    },
+  };
 }
 
 export function createGoosedumpIntegration(
   options: GoosedumpIntegrationOptions = {},
 ): GoosedumpIntegration {
   const shouldRegisterTool = options.registerTool ?? true;
-  const _overrideDefaultCompaction = options.overrideDefaultCompaction ?? false;
+  const shouldOverrideDefaultCompaction = options.overrideDefaultCompaction ?? true;
 
   let goosedumpReady = false;
   let goosedumpEnabled = false;
@@ -430,12 +472,13 @@ export function createGoosedumpIntegration(
           name: 'goosedump',
           label: 'goosedump',
           description:
-            'Browse coding agent session history. List all sessions, or view/search within a session. Supports regex search, compact overview, and result expansion. Default scope is active lineage.',
-          promptSnippet: 'goosedump({ query, scope?, page? }) - search session history',
+            'Browse coding agent session history. List all sessions, or view/search within a session. Supports ranked search, compact overview, and result expansion. Default scope is active lineage.',
+          promptSnippet:
+            'goosedump({ action: "search", contextId, query, scope?, page? }) - search session history',
           promptGuidelines: [
             'When researching past conversation history, use goosedump to find relevant context.',
-            'Start with compact search (compact: true) for quick overview, then expand interesting entries.',
-            'Default scope is "lineage" (current branch); use scope: "all" to search all sessions.',
+            'Start with compact ranked search (compact: true) for quick overview, then expand interesting entries.',
+            'Default scope is "lineage" (current branch); use scope: "all" to include all entries in the session.',
           ],
           parameters: Type.Object({
             action: Type.Union(
@@ -456,12 +499,12 @@ export function createGoosedumpIntegration(
               }),
             ),
             query: Type.Optional(
-              Type.String({ description: 'Regex pattern to search for in messages' }),
+              Type.String({ description: 'Search query to rank messages by relevance' }),
             ),
             scope: Type.Optional(
               Type.Union([Type.Literal('lineage'), Type.Literal('all')], {
                 default: 'lineage',
-                description: 'Scope: lineage (current branch) or all (all sessions)',
+                description: 'Scope: lineage (current branch) or all entries in the session',
               }),
             ),
             compact: Type.Optional(
@@ -548,7 +591,8 @@ export function createGoosedumpIntegration(
                     };
                   }
 
-                  const text = params.compact
+                  const useCompact = params.compact ?? true;
+                  const text = useCompact
                     ? formatMessagesCompact(result.messages)
                     : formatMessagesFull(result.messages);
 
@@ -653,34 +697,41 @@ export function createGoosedumpIntegration(
       }
     });
 
-    pi.on('session_before_compact', async (event, _ctx) => {
-      if (!goosedumpEnabled || !goosedumpReady) return;
+    pi.on('session_before_compact', async (event, ctx) => {
+      if (!shouldOverrideDefaultCompaction || !goosedumpEnabled || !goosedumpReady) return;
+      if (event.customInstructions?.trim()) return;
+      if (event.signal.aborted) return;
 
-      const { messagesToSummarize, firstKeptEntryId, tokensBefore } = event.preparation;
+      const { messagesToSummarize, turnPrefixMessages } = event.preparation;
+      if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) return;
 
-      if (messagesToSummarize.length === 0) return;
+      const contextId = currentSessionContextId(ctx);
+      if (!contextId) return;
 
-      const extracted = extractContextFromMessages(messagesToSummarize as MessageLike[]);
-      const summary = formatCompactionSummary(extracted);
-
-      return {
-        compaction: {
-          summary,
-          firstKeptEntryId,
-          tokensBefore,
-          details: {
-            source: 'goosedump',
-            extracted,
-          },
-        },
-      };
+      try {
+        const compaction = buildGoosedumpCompaction(
+          contextId,
+          event.preparation,
+          event.branchEntries,
+        );
+        return compaction ? { compaction } : undefined;
+      } catch (err) {
+        if (ctx.hasUI) {
+          const message = err instanceof Error ? err.message : String(err);
+          ctx.ui.notify(
+            `goosedump compact failed; falling back to Pi compaction: ${message}`,
+            'error',
+          );
+        }
+        return undefined;
+      }
     });
 
-    pi.on('session_compact', async (event, _ctx) => {
-      if (!goosedumpEnabled || !goosedumpReady) return;
+    pi.on('session_compact', async (event, ctx) => {
+      if (!goosedumpEnabled || !goosedumpReady || !event.fromExtension) return;
 
       const compactionEntry = event.compactionEntry;
-      if (!compactionEntry || compactionEntry.fromHook) return;
+      if (!compactionEntry) return;
 
       const tokensBefore = compactionEntry.tokensBefore;
       const summaryLen = compactionEntry.summary.length;
@@ -688,7 +739,7 @@ export function createGoosedumpIntegration(
       const tokensSaved =
         tokensBefore > 0 ? Math.round((1 - tokenEstimate / tokensBefore) * 100) : 0;
 
-      _ctx.ui.notify(
+      ctx.ui.notify(
         `Goosedump compacted session: ~${tokensSaved}% token reduction (${tokensBefore} → ~${tokenEstimate} tokens)`,
         'info',
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.1.4",
+  "version": "0.2.2",
   "description": "Coding agent context data browser plugin for pi",
   "keywords": [
     "goosedump",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/goosedump": "^0.1.4",
+    "@jarkkojs/goosedump": "^0.2.2",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {