pi-goosedump 0.9.13 → 0.10.0

package/README.md

@@ -20,6 +20,8 @@ If the goosedump binary cannot be resolved, the extension disables itself.
 
 - **goose_search:** ranks messages by query relevance; returns compact entry
   overviews with IDs.
+- **goose_recall:** searches durable memory harvested from earlier compactions,
+  scoped to the current working directory by default.
 - **goose_get:** expands specific entry IDs to their full content.
 - **goose_grep:** filters messages by glob pattern; returns compact entries
   with IDs.
@@ -35,6 +37,7 @@ current branch) or `all`. Targets are always provider-qualified
 
 ```
 goose_search({ query: "bug fix" })
+goose_recall({ query: "prior architecture decision" })
 goose_search({ query: "auth", scope: "all", page: 2 })
 goose_get({ ids: ["entry-a", "entry-b"] })
 goose_get({ ids: ["entry-a"], provider: "claude", session: "1f6b1eba-…" })

package/index.ts

@@ -55,6 +55,17 @@ interface GoosedumpMessage {
   content: string;
 }
 
+interface GoosedumpMemoryHit {
+  hash: string;
+  kind: string;
+  text: string;
+  score: number;
+  provider: string;
+  context_id: string;
+  entry_id: string;
+  path: string;
+}
+
 // A `content` part of a pi-native message line.
 interface PiPartJson {
   type: string;
@@ -234,6 +245,32 @@ function parsePiMessages(output: string): GoosedumpMessage[] {
   return messages;
 }
 
+function parseMemoryHits(output: string): GoosedumpMemoryHit[] {
+  const value = JSON.parse(output) as unknown;
+  if (!Array.isArray(value)) throw new Error('goosedump recall returned invalid JSON');
+  return value.filter(
+    (item): item is GoosedumpMemoryHit =>
+      isRecord(item) &&
+      typeof item.hash === 'string' &&
+      typeof item.kind === 'string' &&
+      typeof item.text === 'string' &&
+      typeof item.score === 'number' &&
+      typeof item.provider === 'string' &&
+      typeof item.context_id === 'string' &&
+      typeof item.entry_id === 'string' &&
+      typeof item.path === 'string',
+  );
+}
+
+function formatMemoryHits(hits: GoosedumpMemoryHit[]): string {
+  return hits
+    .map(
+      (hit) =>
+        `[${hit.hash}] ${hit.kind} (${hit.provider}:${hit.context_id}/${hit.entry_id})\n${hit.text}`,
+    )
+    .join('\n\n---\n\n');
+}
+
 const ANSI_SGR = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g');
 
 function compactLine(content: string): string {
@@ -367,6 +404,18 @@ function goosedumpShow(
   return parsePiMessages(runGoosedump(args));
 }
 
+async function goosedumpRecall(
+  query: string,
+  options: { provider?: string; path?: string; limit?: number } = {},
+  signal?: AbortSignal,
+): Promise<GoosedumpMemoryHit[]> {
+  const args = ['recall', query, '--limit', String(options.limit ?? 5)];
+  if (options.provider) args.push('--provider', options.provider);
+  if (options.path) args.push('--path', options.path);
+  const output = await runGoosedumpAsync(args, signal);
+  return parseMemoryHits(output);
+}
+
 // Resolve a goosedump 0.9 `provider:id` target. An explicit contextId is the
 // target id already; for pi it falls back to the current session. Other
 // providers have no current session and require an explicit id.
@@ -1169,6 +1218,65 @@ export function createGoosedumpIntegration(
 
   function register(pi: ExtensionAPI): void {
     if (shouldRegisterTool) {
+      pi.registerTool(
+        defineTool({
+          name: 'goose_recall',
+          label: 'goose_recall',
+          description:
+            'Recall durable context harvested from earlier compactions. Searches the current project by default and returns full remembered entries with provenance.',
+          promptSnippet: 'Recall durable context from earlier sessions',
+          promptGuidelines: [
+            'Use goose_recall for decisions, evidence, and context that may have disappeared from the current session.',
+            'Results include their original provider, session, entry, and working-directory provenance.',
+            'The current project is searched by default; set allProjects only when cross-project context is appropriate.',
+          ],
+          parameters: Type.Object({
+            query: Type.String({ description: 'Persistent-memory search query' }),
+            provider: Type.Optional(
+              Type.Union(
+                GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)),
+                {
+                  description: 'Optional source-provider filter',
+                },
+              ),
+            ),
+            allProjects: Type.Optional(
+              Type.Boolean({
+                default: false,
+                description: 'Search memory from every working directory',
+              }),
+            ),
+            limit: Type.Optional(
+              Type.Integer({
+                minimum: 1,
+                maximum: 20,
+                default: 5,
+                description: 'Maximum remembered entries to return',
+              }),
+            ),
+          }),
+          async execute(_id, params, signal, _onUpdate, ctx): Promise<AgentToolResult<void>> {
+            if (!goosedumpAvailable) return goosedumpUnavailableResult();
+            try {
+              const hits = await goosedumpRecall(
+                params.query,
+                {
+                  provider: params.provider,
+                  path: params.allProjects ? undefined : ctx.cwd,
+                  limit: params.limit,
+                },
+                signal,
+              );
+              if (hits.length === 0) return textResult(`No durable memory for "${params.query}"`);
+              return textResult(formatMemoryHits(hits));
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              return textResult(`goosedump error: ${message}`);
+            }
+          },
+        }),
+      );
+
       pi.registerTool(
         defineTool({
           name: 'goose_search',

package/package.json

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