pi-goosedump 0.6.2 → 0.6.4

package/README.md

@@ -21,7 +21,8 @@ Once installed, pi-goosedump registers a tool and a slash command:
 
 ### Tool: `goosedump`
 
-The agent can browse the current Pi session by default or a named session with `contextId`:
+The agent can browse the current Pi session by default, or any session by its
+8-hex `contextId` (the id shown by `list`):
 
 | Action   | Description                              |
 | -------- | ---------------------------------------- |
@@ -36,7 +37,7 @@ Examples:
 ```
 goosedump({ action: "list" })
 goosedump({ action: "search", query: "bug fix" })
-goosedump({ action: "search", contextId: "abc123", query: "bug fix" })
+goosedump({ action: "search", contextId: "0000001f", query: "bug fix" })
 goosedump({ action: "grep", pattern: "*rand*" })
 goosedump({ action: "expand", ids: ["entry-a", "entry-b"] })
 goosedump({ action: "view" })
@@ -52,7 +53,7 @@ Non-pi providers have no current session, so they require an explicit
 
 ```
 goosedump({ action: "list", provider: "claude" })
-goosedump({ action: "view", provider: "claude", contextId: "abc123" })
+goosedump({ action: "view", provider: "claude", contextId: "0000001f" })
 ```
 
 #### Raw native output
@@ -76,10 +77,10 @@ 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.
+pi-goosedump hooks Pi's `/compact` and auto-compaction flow. It resolves the
+current session to its goosedump id and runs `goosedump compact <id>` with Pi's
+compaction range (`--from`, `--until`, and `--scope`) so the generated summary
+matches the entries Pi is about to replace.
 
 ## License
 

package/index.ts

@@ -13,10 +13,10 @@ import type {
 import { defineTool } from '@earendil-works/pi-coding-agent';
 
 import { execFileSync } from 'node:child_process';
-import { type Dirent, existsSync, readdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
-import { basename, extname, join } from 'node:path';
+import { basename, extname, isAbsolute, join, relative } from 'node:path';
 
 import {
   Key,
@@ -29,10 +29,27 @@ import { Type } from '@sinclair/typebox';
 
 const require = createRequire(import.meta.url);
 
-const GOOSEDUMP_VERSION = [0, 6, 2] as const;
+const GOOSEDUMP_VERSION = [0, 7, 4] as const;
+
+// One element of goosedump 0.7's `list` JSON output.
+interface ListEntryJson {
+  id: string;
+  parent: string | null;
+  provider: string;
+  native_id: string;
+  cwd: string;
+  count: number;
+  label: string | null;
+  from: string | null;
+  until: string | null;
+}
 
 interface GoosedumpListing {
   id: string;
+  provider: string;
+  nativeId: string;
+  cwd: string;
+  label: string | null;
   path: string | null;
 }
 
@@ -248,16 +265,18 @@ function runGoosedump(args: string[]): string {
 }
 
 function goosedumpList(provider = 'pi'): GoosedumpListing[] {
-  const prefix = `${provider}:`;
-  const ids = runGoosedump(['list', `${prefix}*`])
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith(prefix))
-    .map((line) => line.slice(prefix.length));
-
-  // Only pi sessions live in the local sessions tree we can map back to files.
-  const paths = provider === 'pi' ? indexPiSessionPaths() : new Map<string, string>();
-  return ids.map((id) => ({ id, path: paths.get(id) ?? null }));
+  const entries = JSON.parse(runGoosedump(['list'])) as ListEntryJson[];
+  return entries
+    .filter((entry) => entry.provider === provider)
+    .map((entry) => ({
+      id: entry.id,
+      provider: entry.provider,
+      nativeId: entry.native_id,
+      cwd: entry.cwd,
+      label: entry.label ?? null,
+      // Only pi sessions map back to a local file we can resume.
+      path: provider === 'pi' ? piSessionFilePath(entry.native_id) : null,
+    }));
 }
 
 function piSessionsDir(): string {
@@ -267,30 +286,11 @@ function piSessionsDir(): string {
   return join(agentDir, 'sessions');
 }
 
-// goosedump's `list` no longer reports session file paths, so map each pi
-// session id back to its file by scanning the sessions tree, matching the same
-// id goosedump derives from the session file stem.
-function indexPiSessionPaths(): Map<string, string> {
-  const paths = new Map<string, string>();
-  const walk = (dir: string): void => {
-    let entries: Dirent[];
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
-        const id = sessionFileContextId(full);
-        if (id && !paths.has(id)) paths.set(id, full);
-      }
-    }
-  };
-  walk(piSessionsDir());
-  return paths;
+// goosedump derives a pi native id from the session file path relative to the
+// sessions base (without extension), so reconstruct the file path the same way.
+function piSessionFilePath(nativeId: string): string | null {
+  const path = join(piSessionsDir(), `${nativeId}.jsonl`);
+  return existsSync(path) ? path : null;
 }
 
 function goosedumpSearch(
@@ -326,17 +326,17 @@ function goosedumpShow(
 ): GoosedumpMessage[] {
   const scope = options.scope ?? 'lineage';
   const args = ['show', target];
-  if (options.ids && options.ids.length > 0) args.push('--ids', options.ids.join(','));
+  for (const id of options.ids ?? []) args.push('-m', id);
   args.push('--scope', scope);
 
   const json = JSON.parse(runGoosedump(args)) as ShowJson;
   return (json.messages ?? []).map(showMessage);
 }
 
-// goosedump 0.6.2+ accepts --output-format on show/grep/search to emit a context
-// in a provider's native, round-trippable format. That output is raw native text
-// (not the ShowJson/HitJson shapes), so this bypasses the JSON-parsing wrappers
-// and returns it verbatim. Only used when the caller explicitly sets outputFormat.
+// goosedump accepts --output-format on show/grep/search to emit a context in a
+// provider's native, round-trippable format. That output is raw native text (not
+// the ShowJson/HitJson shapes), so this bypasses the JSON-parsing wrappers and
+// returns it verbatim. Only used when the caller explicitly sets outputFormat.
 function goosedumpConvert(
   subcommand: 'show' | 'grep' | 'search',
   target: string,
@@ -344,22 +344,23 @@ function goosedumpConvert(
   options: { positionals?: string[]; scope?: string; ids?: string[]; page?: number } = {},
 ): string {
   const args = [subcommand, target, ...(options.positionals ?? [])];
-  if (options.ids && options.ids.length > 0) args.push('--ids', options.ids.join(','));
+  for (const id of options.ids ?? []) args.push('-m', id);
   if (options.page) args.push('--page', String(options.page));
   args.push('--scope', options.scope ?? 'lineage', '--output-format', outputFormat);
   return runGoosedump(args);
 }
 
-// Resolve a <provider>:<contextId> target. contextId falls back to the current
-// session only for pi; other providers have no current session, so they require
-// an explicit contextId.
+// Resolve a goosedump target id. In 0.7 every context is addressed by its 8-hex
+// index id, so an explicit contextId is already the target. It falls back to the
+// current session only for pi; other providers have no current session, so they
+// require an explicit contextId.
 function resolveTarget(
   ctx: ExtensionContext,
   provider: string,
   contextId: string | undefined,
 ): string | null {
-  const id = contextId ?? (provider === 'pi' ? currentSessionContextId(ctx) : null);
-  return id ? `${provider}:${id}` : null;
+  if (contextId) return contextId;
+  return provider === 'pi' ? currentSessionContextId(ctx) : null;
 }
 
 function capList(items: string[], limit: number): string {
@@ -391,7 +392,7 @@ function renderCompactSummary(c: CompactJson): string {
 }
 
 function goosedumpCompact(
-  contextId: string,
+  target: string,
   options: {
     scope?: string;
     from?: string;
@@ -400,10 +401,10 @@ function goosedumpCompact(
   },
 ): string {
   const scope = options.scope ?? 'lineage';
-  const args = ['compact', `pi:${contextId}`, '--scope', scope];
+  const args = ['compact', target, '--scope', scope];
 
   if (options.ids && options.ids.length > 0) {
-    args.push('--ids', options.ids.join(','));
+    for (const id of options.ids) args.push('-m', id);
   } else {
     if (options.from) args.push('--from', options.from);
     if (options.until) args.push('--until', options.until);
@@ -445,18 +446,28 @@ export default function (pi: ExtensionAPI) {
   createGoosedumpIntegration().register(pi);
 }
 
-function sessionFileContextId(sessionFile: string | null | undefined): string | null {
-  if (!sessionFile) return null;
-
-  // goosedump 0.6+ derives a pi context id from the session file stem (file name
-  // without its extension), so match that exactly rather than the inner UUID.
-  const name = basename(sessionFile);
-  const ext = extname(name);
-  return ext ? name.slice(0, -ext.length) : name;
+// Compute the pi native id goosedump assigns to a session file: its path relative
+// to the sessions base without the .jsonl extension, or the bare stem when the
+// file lives outside that base (mirroring goosedump's own fallback).
+function sessionFileNativeId(sessionFile: string): string {
+  const rel = relative(piSessionsDir(), sessionFile);
+  if (rel === '' || rel.startsWith('..') || isAbsolute(rel)) {
+    const name = basename(sessionFile);
+    const ext = extname(name);
+    return ext ? name.slice(0, -ext.length) : name;
+  }
+  const ext = extname(rel);
+  return ext ? rel.slice(0, -ext.length) : rel;
 }
 
+// Resolve the current pi session to its goosedump 8-hex context id by matching the
+// session file's native id against goosedump's index (via `list`).
 function currentSessionContextId(ctx: ExtensionContext): string | null {
-  return sessionFileContextId(ctx.sessionManager.getSessionFile());
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  if (!sessionFile) return null;
+  const nativeId = sessionFileNativeId(sessionFile);
+  const listing = goosedumpList('pi').find((entry) => entry.nativeId === nativeId);
+  return listing ? listing.id : null;
 }
 
 function isCompactionEntry(entry: SessionEntry): entry is CompactionEntry {
@@ -897,18 +908,21 @@ export function createGoosedumpIntegration(
             'Set outputFormat (e.g. "claude", "json") only when you explicitly need the raw native session instead of the rendered view.',
           ],
           parameters: Type.Object({
-            action: Type.Union(
-              [
-                Type.Literal('list'),
-                Type.Literal('search'),
-                Type.Literal('grep'),
-                Type.Literal('expand'),
-                Type.Literal('view'),
-              ],
-              {
-                description:
-                  'Operation: list sessions, search within a session, grep by glob pattern, expand entries, or view full session',
-              },
+            action: Type.Optional(
+              Type.Union(
+                [
+                  Type.Literal('list'),
+                  Type.Literal('search'),
+                  Type.Literal('grep'),
+                  Type.Literal('expand'),
+                  Type.Literal('view'),
+                ],
+                {
+                  default: 'list',
+                  description:
+                    'Operation: list sessions, search within a session, grep by glob pattern, expand entries, or view full session. Defaults to list.',
+                },
+              ),
             ),
             contextId: Type.Optional(
               Type.String({
@@ -991,7 +1005,7 @@ export function createGoosedumpIntegration(
             }
 
             try {
-              switch (params.action) {
+              switch (params.action ?? 'list') {
                 case 'list': {
                   const listings = goosedumpList(params.provider ?? 'pi');
                   if (listings.length === 0) {
@@ -1000,7 +1014,8 @@ export function createGoosedumpIntegration(
 
                   const lines = ['Available sessions:', ''];
                   for (const listing of listings) {
-                    lines.push(`  ${listing.id}`);
+                    const suffix = listing.label ? `${listing.cwd}  ${listing.label}` : listing.cwd;
+                    lines.push(`  ${listing.id}  ${suffix}`);
                   }
 
                   return textResult(lines.join('\n'));
@@ -1119,16 +1134,14 @@ export function createGoosedumpIntegration(
                   const messages = goosedumpShow(target, { scope: params.scope ?? 'lineage' });
 
                   if (messages.length === 0) {
-                    return textResult(
-                      `Session "${target.slice(provider.length + 1)}" has no messages.`,
-                    );
+                    return textResult(`Session "${target}" has no messages.`);
                   }
 
                   return textResult(formatMessagesFull(messages));
                 }
 
                 default:
-                  return textResult(`Unknown action: ${params.action}`);
+                  return textResult(`Unknown action: ${params.action ?? 'list'}`);
               }
             } catch (err) {
               const message = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "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.6.5",
+    "@jarkkojs/goosedump": "^0.7.4",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {