pi-sessions 0.6.0 → 0.7.0

package/extensions/session-ask.ts

@@ -1,23 +1,15 @@
-import type { Message } from "@earendil-works/pi-ai";
-import { complete } from "@earendil-works/pi-ai/compat";
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
+import { getKeybindings, type Keybinding, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { type RenderedSessionTree, renderSessionTreeMarkdown } from "./session-search/extract.ts";
+import { runSessionAskAgent } from "./session-ask/agent.ts";
 import {
-  getIndexStatus,
   getSessionById,
-  INDEX_SCHEMA_VERSION,
-  openIndexDatabase,
   type SessionLineageRow,
+  withSessionIndex,
 } from "./shared/session-index/index.ts";
 import { formatSessionTitleOrShortId, isExactSessionId } from "./shared/session-ui.ts";
 import { loadSettings } from "./shared/settings.ts";
 
-const SESSION_ASK_SYSTEM_PROMPT = `You are analyzing a Pi coding session transcript. The transcript includes the entire session tree, including abandoned branches and summaries.
-
-Answer the user's question using only the session contents. Be specific and concise. Include exact file paths, decisions, and outcomes when present. If the answer is not in the session, say so clearly.`;
-
 const COLLAPSED_ANSWER_PREVIEW_ROWS = 6;
 
 interface SessionAskToolParams {
@@ -25,21 +17,21 @@ interface SessionAskToolParams {
   question: string;
 }
 
+interface SessionAskRelevantFile {
+  path: string;
+  reason: string;
+}
+
 interface SessionAskToolDetails {
-  cancelled?: boolean | undefined;
-  error?: boolean | undefined;
   answer?: string | undefined;
+  debugSessionPath?: string | undefined;
   question?: string | undefined;
+  relevantFiles?: SessionAskRelevantFile[] | undefined;
   sessionId?: string | undefined;
   sessionName?: string | undefined;
   sessionPath?: string | undefined;
 }
 
-interface TextContentBlock {
-  type: "text";
-  text: string;
-}
-
 export default function sessionAskExtension(pi: ExtensionAPI): void {
   const settings = loadSettings();
 
@@ -61,32 +53,17 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
     async execute(_toolCallId, params: SessionAskToolParams, signal, onUpdate, ctx) {
       const sessionId = params.session.trim();
       if (!sessionId) {
-        return errorResult("session_ask requires a session id.", { error: true });
+        throw new Error("session_ask requires a session id.");
       }
 
       const question = params.question.trim();
       if (!question) {
-        return errorResult("session_ask requires a question.", { error: true, sessionId });
+        throw new Error("session_ask requires a question.");
       }
 
       const resolvedTarget = resolveSessionAskTarget(sessionId, settings.index.path);
       if (!resolvedTarget.resolved) {
-        return errorResult(resolvedTarget.error ?? "Unable to resolve session id.", {
-          error: true,
-          sessionId,
-          question,
-        });
-      }
-
-      if (!ctx.model) {
-        return errorResult("No active model is available for session_ask.", { error: true });
-      }
-
-      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
-      if (!auth.ok || !auth.apiKey) {
-        return errorResult(`No API key is available for ${ctx.model.provider}/${ctx.model.id}.`, {
-          error: true,
-        });
+        throw new Error(resolvedTarget.error ?? "Unable to resolve session id.");
       }
 
       const progressDetails: SessionAskToolDetails = {
@@ -100,68 +77,41 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         details: progressDetails,
       });
 
-      let rendered: RenderedSessionTree;
-      try {
-        rendered = renderSessionTreeMarkdown(resolvedTarget.resolved.sessionPath);
-      } catch (error) {
-        return errorResult(formatSessionAskLoadError(resolvedTarget.resolved.sessionPath, error), {
-          error: true,
-          sessionId,
-          sessionPath: resolvedTarget.resolved.sessionPath,
-          question,
-        });
-      }
-
-      const loadedDetails: SessionAskToolDetails = {
-        question,
-        sessionId: rendered.sessionId,
-        sessionName: rendered.sessionName,
-        sessionPath: resolvedTarget.resolved.sessionPath,
-      };
       onUpdate?.({
         content: [
           {
             type: "text",
-            text: formatSessionAskHeader(rendered.sessionId, rendered.sessionName, question),
+            text: formatSessionAskHeader(
+              resolvedTarget.resolved.sessionId,
+              resolvedTarget.resolved.sessionName,
+              question,
+            ),
           },
         ],
-        details: loadedDetails,
+        details: progressDetails,
       });
 
-      const userMessage: Message = {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: [`## Session`, rendered.markdown, "", "## Question", question].join("\n"),
-          },
-        ],
-        timestamp: Date.now(),
-      };
-
-      const response = await complete(
-        ctx.model,
-        { systemPrompt: SESSION_ASK_SYSTEM_PROMPT, messages: [userMessage] },
-        signal
-          ? {
-              apiKey: auth.apiKey,
-              ...(auth.headers ? { headers: auth.headers } : {}),
-              signal,
-            }
-          : {
-              apiKey: auth.apiKey,
-              ...(auth.headers ? { headers: auth.headers } : {}),
-            },
-      );
+      const agentResult = await runSessionAskAgent({
+        ctx,
+        target: resolvedTarget.resolved,
+        question,
+        indexPath: settings.index.path,
+        askSettings: settings.ask,
+        thinkingLevel: pi.getThinkingLevel(),
+        signal,
+      });
 
-      if (response.stopReason === "aborted") {
-        return errorResult("Session ask was cancelled.", { cancelled: true });
+      if (signal?.aborted) {
+        throw new Error("Session ask was cancelled.");
       }
 
-      const answer = collectTextBlocks(response.content).join("\n").trim();
+      const answer = agentResult?.answer || "Could not determine an answer from the session.";
+      const relevantFiles = agentResult?.relevantFiles ?? [];
 
       const details: SessionAskToolDetails = {
         answer,
+        debugSessionPath: agentResult?.debugSessionPath,
+        relevantFiles,
         sessionId: resolvedTarget.resolved.sessionId,
         sessionName: resolvedTarget.resolved.sessionName,
         sessionPath: resolvedTarget.resolved.sessionPath,
@@ -172,21 +122,29 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
           {
             type: "text",
             text: [
-              formatSessionAskHeader(rendered.sessionId, rendered.sessionName, question),
-              answer || "No answer generated.",
+              formatSessionAskHeader(
+                resolvedTarget.resolved.sessionId,
+                resolvedTarget.resolved.sessionName,
+                question,
+              ),
+              formatSessionAskAnswer(answer, relevantFiles, agentResult?.debugSessionPath),
             ].join("\n\n"),
           },
         ],
         details,
       };
     },
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderResult(result, { expanded, isPartial }, theme, context) {
       const details = result.details as SessionAskToolDetails | undefined;
       const content = result.content[0];
       if (content?.type !== "text") {
         return new Text(theme.fg("error", "No session output"), 0, 0);
       }
 
+      if (context.isError) {
+        return new Text(theme.fg("error", content.text), 0, 0);
+      }
+
       if (isPartial) {
         const lines = [theme.bold(theme.fg("warning", "Reading session..."))];
         if (details?.sessionId || details?.sessionName) {
@@ -199,14 +157,6 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         return new Text(lines.join("\n"), 0, 0);
       }
 
-      if (details?.cancelled) {
-        return new Text(theme.fg("warning", content.text), 0, 0);
-      }
-
-      if (details?.error) {
-        return new Text(theme.fg("error", content.text), 0, 0);
-      }
-
       const answer = (details?.answer ?? "").trim() || "No answer generated.";
       const identity = formatSessionTitleOrShortId(details?.sessionName, details?.sessionId);
       const lines = [`title: ${theme.bold(identity)}`];
@@ -234,30 +184,20 @@ function resolveSessionAskTarget(
     };
   }
 
-  const status = getIndexStatus(indexPath);
-  if (!status.exists || status.schemaVersion !== INDEX_SCHEMA_VERSION) {
-    return {
-      error: `Session index missing or incompatible at ${indexPath}. Run /session-index and press r to rebuild it.`,
-    };
-  }
-
-  const db = openIndexDatabase(status.dbPath, { create: false });
   try {
-    const row = getSessionById(db, sessionId);
-    if (!row) {
-      return { error: `No indexed session found for id: ${sessionId}` };
-    }
+    return withSessionIndex(indexPath, { mode: "read", required: true }, ({ db }) => {
+      const row = getSessionById(db, sessionId);
+      if (!row) {
+        return { error: `No indexed session found for id: ${sessionId}` };
+      }
 
-    return { resolved: row };
-  } finally {
-    db.close();
+      return { resolved: row };
+    });
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
   }
 }
 
-function collectTextBlocks(content: Array<{ type: string; text?: string }>): string[] {
-  return content.filter(isTextContentBlock).map((block) => block.text);
-}
-
 function formatSessionAskHeader(sessionId: string, sessionName: string, question: string): string {
   return [
     `session: ${sessionId}`,
@@ -266,14 +206,20 @@ function formatSessionAskHeader(sessionId: string, sessionName: string, question
   ].join("\n");
 }
 
-function errorResult(
-  text: string,
-  details: SessionAskToolDetails,
-): { content: Array<{ type: "text"; text: string }>; details: SessionAskToolDetails } {
-  return {
-    content: [{ type: "text", text }],
-    details,
-  };
+function formatSessionAskAnswer(
+  answer: string,
+  relevantFiles: SessionAskRelevantFile[],
+  debugSessionPath: string | undefined,
+): string {
+  const lines = [answer || "No answer generated."];
+  if (relevantFiles.length > 0) {
+    lines.push("", "Relevant files:");
+    lines.push(...relevantFiles.map((file) => `- ${file.path}: ${file.reason}`));
+  }
+  if (debugSessionPath) {
+    lines.push("", `debug_session: ${debugSessionPath}`);
+  }
+  return lines.join("\n");
 }
 
 function formatSessionAskAnswerPreview(answer: string, expanded: boolean, theme: Theme): string[] {
@@ -282,17 +228,19 @@ function formatSessionAskAnswerPreview(answer: string, expanded: boolean, theme:
     return lines;
   }
 
-  return [...lines.slice(0, COLLAPSED_ANSWER_PREVIEW_ROWS), theme.fg("dim", "...")];
+  return [
+    ...lines.slice(0, COLLAPSED_ANSWER_PREVIEW_ROWS),
+    formatOverflowHint(lines.length - COLLAPSED_ANSWER_PREVIEW_ROWS, lines.length, theme),
+  ];
 }
 
-function formatSessionAskLoadError(sessionPath: string, error: unknown): string {
-  if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-    return `Session file not found: ${sessionPath}`;
-  }
-
-  return `Unable to load session file: ${sessionPath}`;
+function formatOverflowHint(remaining: number, total: number, theme: Theme): string {
+  return `${theme.fg("muted", `... (${remaining} more lines, ${total} total,`)} ${theme.fg(
+    "dim",
+    formatKeyHint("app.tools.expand"),
+  )}${theme.fg("muted", " to expand)")}`;
 }
 
-function isTextContentBlock(content: { type: string; text?: string }): content is TextContentBlock {
-  return content.type === "text" && typeof content.text === "string";
+function formatKeyHint(keybinding: Keybinding): string {
+  return getKeybindings().getKeys(keybinding).join("/");
 }

package/extensions/session-auto-title/model.ts

@@ -1,5 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { findModelByReference } from "../shared/model.ts";
 import { ModelReference } from "../shared/settings.ts";
 
 const DEFAULT_AUTO_TITLE_FALLBACK_MODELS: readonly ModelReference[] = [
@@ -22,7 +23,7 @@ export function resolveAutoTitleModel(
   const availableModels = ctx.modelRegistry.getAvailable();
 
   if (configuredModel) {
-    const configuredMatch = findMatchingModel(availableModels, configuredModel);
+    const configuredMatch = findModelByReference(availableModels, configuredModel);
     if (configuredMatch) {
       return {
         model: configuredMatch,
@@ -32,7 +33,7 @@ export function resolveAutoTitleModel(
   }
 
   for (const fallbackReference of DEFAULT_AUTO_TITLE_FALLBACK_MODELS) {
-    const fallbackMatch = findMatchingModel(availableModels, fallbackReference);
+    const fallbackMatch = findModelByReference(availableModels, fallbackReference);
     if (fallbackMatch) {
       return {
         model: fallbackMatch,
@@ -50,12 +51,3 @@ export function resolveAutoTitleModel(
     source: "current",
   };
 }
-
-function findMatchingModel(
-  availableModels: Model<Api>[],
-  reference: ModelReference,
-): Model<Api> | undefined {
-  return availableModels.find(
-    (model) => model.provider === reference.provider && model.id === reference.modelId,
-  );
-}

package/extensions/session-handoff/picker.ts

@@ -16,6 +16,7 @@ import { listSessionPickerItems, normalizeDisplayText, type SessionPickerItem }
 
 const MAX_VISIBLE_BROWSE_ROWS = 10;
 const MAX_VISIBLE_SEARCH_ROWS = 4;
+const SEARCH_RELOAD_DEBOUNCE_MS = 200;
 
 interface PickerRightColumnWidths {
   marker: number;
@@ -65,6 +66,7 @@ export class SessionReferencePickerComponent implements Focusable {
   private includeAll = false;
   private items: SessionPickerItem[] = [];
   private selectedIndex = 0;
+  private searchReloadTimer: ReturnType<typeof setTimeout> | undefined;
 
   get focused(): boolean {
     return this._focused;
@@ -89,17 +91,18 @@ export class SessionReferencePickerComponent implements Focusable {
 
   handleInput(data: string): void {
     if (matchesKey(data, this.options.shortcut)) {
-      this.done({ kind: "cancel" });
+      this.finish({ kind: "cancel" });
       return;
     }
 
     if (this.keybindings.matches(data, "tui.select.cancel")) {
-      this.done({ kind: "cancel" });
+      this.finish({ kind: "cancel" });
       return;
     }
 
     if (this.keybindings.matches(data, "tui.input.tab")) {
       this.includeAll = !this.includeAll;
+      this.cancelSearchReload();
       this.reload();
       this.tui.requestRender();
       return;
@@ -130,9 +133,10 @@ export class SessionReferencePickerComponent implements Focusable {
     }
 
     if (this.keybindings.matches(data, "tui.select.confirm")) {
+      this.flushSearchReload();
       const selected = this.items[this.selectedIndex];
       if (selected?.kind === "session") {
-        this.done({ kind: "insert-session-token", sessionId: selected.sessionId });
+        this.finish({ kind: "insert-session-token", sessionId: selected.sessionId });
       }
       return;
     }
@@ -140,7 +144,7 @@ export class SessionReferencePickerComponent implements Focusable {
     const before = this.input.getValue();
     this.input.handleInput(data);
     if (this.input.getValue() !== before) {
-      this.reload();
+      this.reloadAfterInputChange();
       this.tui.requestRender();
     }
   }
@@ -284,6 +288,48 @@ export class SessionReferencePickerComponent implements Focusable {
       .trim();
   }
 
+  private reloadAfterInputChange(): void {
+    if (!this.input.getValue().trim()) {
+      this.cancelSearchReload();
+      this.reload();
+      return;
+    }
+
+    this.scheduleSearchReload();
+  }
+
+  private scheduleSearchReload(): void {
+    this.cancelSearchReload();
+    this.searchReloadTimer = setTimeout(() => {
+      this.searchReloadTimer = undefined;
+      this.reload();
+      this.tui.requestRender();
+    }, SEARCH_RELOAD_DEBOUNCE_MS);
+  }
+
+  private flushSearchReload(): void {
+    if (!this.searchReloadTimer) {
+      return;
+    }
+
+    this.cancelSearchReload();
+    this.reload();
+  }
+
+  private cancelSearchReload(): void {
+    if (!this.searchReloadTimer) {
+      return;
+    }
+
+    clearTimeout(this.searchReloadTimer);
+    this.searchReloadTimer = undefined;
+  }
+
+  private finish(result: SessionPickerResult): void {
+    this.cancelSearchReload();
+    this.done(result);
+  }
+
   private reload(): void {
     this.items = listSessionPickerItems({
       currentSessionPath: this.options.getCurrentSessionPath(),

package/extensions/session-handoff/query.ts

@@ -1,15 +1,13 @@
 import { stripSearchSnippetMarkers } from "../shared/search-snippet.ts";
 import {
-  getIndexStatus,
-  getLineageRelationMap,
   getSessionByPath,
-  INDEX_SCHEMA_VERSION,
-  openIndexDatabase,
   type SearchSessionResult,
   type SessionIndexDatabase,
   type SessionLineageRelation,
   searchSessions,
+  withSessionIndex,
 } from "../shared/session-index/index.ts";
+import { SearchQuerySyntaxError } from "../shared/session-index/query/ast.ts";
 import { shortenSessionId } from "../shared/session-ui.ts";
 import { formatCompactRelativeTime } from "../shared/time.ts";
 
@@ -19,7 +17,6 @@ const MAX_TREE_DEPTH = 3;
 
 interface SessionPickerPresentationContext {
   currentSessionId?: string | undefined;
-  relationBySessionId: Map<string, SessionLineageRelation>;
 }
 
 export interface SessionPickerSessionItem {
@@ -32,7 +29,7 @@ export interface SessionPickerSessionItem {
   modifiedAtText?: string | undefined;
   prefix: string;
   snippet?: string | undefined;
-  relation?: SessionLineageRelation | "self" | undefined;
+  relation?: SessionLineageRelation | undefined;
 }
 
 export interface SessionPickerNoticeItem {
@@ -69,67 +66,75 @@ export function listSessionPickerItems(
 ): SessionPickerQueryResult {
   const scopeMode = options.includeAll ? "all" : "default";
   const defaultScopeLabel = options.currentCwd ? "current folder" : undefined;
-  const status = getIndexStatus(options.indexPath);
-  if (!status.exists || status.schemaVersion !== INDEX_SCHEMA_VERSION) {
-    return {
-      items: [buildIndexErrorItem()],
-      scopeMode,
-      defaultScopeLabel,
-    };
-  }
-
-  const db = openIndexDatabase(status.dbPath, { create: false });
   try {
-    const currentSession = options.currentSessionPath
-      ? getSessionByPath(db, options.currentSessionPath)
-      : undefined;
-    const context = buildPresentationContext(db, currentSession?.sessionId);
-    const rankedResults = prioritizeSessionResults(
-      searchSessions(
-        db,
-        {
-          cwd: options.includeAll ? undefined : options.currentCwd,
-          query: options.mode === "search" ? options.query : undefined,
-          limit: options.limit,
-        },
-        { defaultLimit: undefined },
-      ),
-      context,
+    return (
+      withSessionIndex(options.indexPath, { mode: "read", required: false }, ({ db }) => {
+        const currentSession = options.currentSessionPath
+          ? getSessionByPath(db, options.currentSessionPath)
+          : undefined;
+        const context = buildPresentationContext(currentSession?.sessionId);
+        const searchResults = searchSessionsSafely(db, options, currentSession?.sessionId);
+        const rankedResults =
+          options.mode === "browse"
+            ? prioritizeSessionResults(searchResults, context)
+            : searchResults;
+
+        if (rankedResults.length === 0) {
+          return {
+            items: [buildEmptyResultItem(options.mode)],
+            scopeMode,
+            defaultScopeLabel,
+          };
+        }
+
+        const sessionItems =
+          options.mode === "browse"
+            ? buildBrowseSessionItems(rankedResults, context)
+            : rankedResults.map((result) =>
+                buildSessionItem(result, context, "", getBestTextSnippet(result)),
+              );
+
+        return {
+          items: sessionItems,
+          scopeMode,
+          defaultScopeLabel,
+        };
+      }) ?? {
+        items: [buildIndexErrorItem()],
+        scopeMode,
+        defaultScopeLabel,
+      }
     );
-
-    if (rankedResults.length === 0) {
+  } catch (error) {
+    if (error instanceof SearchQuerySyntaxError) {
       return {
-        items: [buildEmptyResultItem(options.mode)],
+        items: [buildSearchSyntaxErrorItem(error)],
         scopeMode,
         defaultScopeLabel,
       };
     }
 
-    const sessionItems =
-      options.mode === "browse"
-        ? buildBrowseSessionItems(rankedResults, context)
-        : rankedResults.map((result) => buildSessionItem(result, context, "", result.snippet));
-
-    return {
-      items: sessionItems,
-      scopeMode,
-      defaultScopeLabel,
-    };
-  } finally {
-    db.close();
+    throw error;
   }
 }
 
-function buildPresentationContext(
+function searchSessionsSafely(
   db: SessionIndexDatabase,
+  options: ListSessionPickerItemsOptions,
+  currentSessionId?: string | undefined,
+): SearchSessionResult[] {
+  return searchSessions(db, {
+    cwd: options.includeAll ? undefined : options.currentCwd,
+    query: options.mode === "search" ? options.query : undefined,
+    limit: options.limit,
+    relativeToSessionId: currentSessionId,
+  });
+}
+
+function buildPresentationContext(
   currentSessionId?: string | undefined,
 ): SessionPickerPresentationContext {
-  return {
-    currentSessionId,
-    relationBySessionId: currentSessionId
-      ? getLineageRelationMap(db, currentSessionId)
-      : new Map<string, SessionLineageRelation>(),
-  };
+  return { currentSessionId };
 }
 
 function prioritizeSessionResults(
@@ -251,13 +256,18 @@ function buildSessionItem(
   };
 }
 
+function getBestTextSnippet(result: SearchSessionResult): string | undefined {
+  const textEvidence = result.evidence.find((evidence) => evidence.kind === "text");
+  return textEvidence?.kind === "text" ? textEvidence.snippet : undefined;
+}
+
 function getSessionTitle(result: SearchSessionResult): string {
   return (
     normalizeDisplayText(result.sessionName) ??
     normalizeDisplayText(result.handoffNextTask) ??
     normalizeDisplayText(result.handoffGoal) ??
     normalizeDisplayText(result.firstUserPrompt) ??
-    normalizeDisplayText(stripSearchSnippetMarkers(result.snippet)) ??
+    normalizeDisplayText(stripSearchSnippetMarkers(getBestTextSnippet(result))) ??
     shortenSessionId(result.sessionId)
   );
 }
@@ -274,12 +284,12 @@ export function normalizeDisplayText(value?: string): string | undefined {
 function getSessionRelation(
   result: SearchSessionResult,
   context: SessionPickerPresentationContext,
-): SessionLineageRelation | "self" | undefined {
+): SessionLineageRelation | undefined {
   if (context.currentSessionId && result.sessionId === context.currentSessionId) {
     return "self";
   }
 
-  return context.relationBySessionId.get(result.sessionId);
+  return result.relation;
 }
 
 function getSessionMarker(
@@ -308,6 +318,14 @@ function buildIndexErrorItem(): SessionPickerNoticeItem {
   };
 }
 
+function buildSearchSyntaxErrorItem(error: SearchQuerySyntaxError): SessionPickerNoticeItem {
+  return {
+    kind: "error",
+    title: "Invalid search query",
+    description: error.message,
+  };
+}
+
 function buildEmptyResultItem(mode: "browse" | "search"): SessionPickerNoticeItem {
   return {
     kind: "empty",