pi-sessions 0.6.0 → 0.7.0

package/extensions/session-search/hooks.ts

@@ -8,13 +8,10 @@ import {
 import {
   clearSessionChunksBySourceKind,
   clearSessionIndexedData,
-  getMetadata,
   getSessionById,
   getSessionRowByPath,
-  INDEX_SCHEMA_VERSION,
   insertSessionFileTouch,
   insertTextChunk,
-  openIndexDatabase,
   refreshSessionLineageRelationsFor,
   type SessionIndexDatabase,
   type SessionLineageRow,
@@ -22,6 +19,7 @@ import {
   type SessionRow,
   setMetadata,
   upsertSession,
+  withSessionIndex,
 } from "../shared/session-index/index.ts";
 import {
   createSessionNameChunk,
@@ -198,24 +196,19 @@ function syncSessionFile(
   state?: SessionHookState,
   sessionOrigin?: SessionOrigin,
 ): boolean {
-  if (!sessionFile || !existsSync(sessionFile) || !existsSync(indexPath)) {
+  if (!sessionFile || !existsSync(sessionFile)) {
     return false;
   }
 
-  const db = openIndexDatabase(indexPath, { create: false });
-  try {
-    if (readIndexSchemaVersion(db) !== INDEX_SCHEMA_VERSION) {
-      return false;
-    }
-
-    const synced = syncSessionFileWithDb(db, sessionFile, eventType, sessionOrigin);
-    if (synced && state) {
-      state.lastFlushedSessionFile = sessionFile;
-    }
-    return synced;
-  } finally {
-    db.close();
-  }
+  return (
+    withSessionIndex(indexPath, { mode: "write", required: false }, ({ db }) => {
+      const synced = syncSessionFileWithDb(db, sessionFile, eventType, sessionOrigin);
+      if (synced && state) {
+        state.lastFlushedSessionFile = sessionFile;
+      }
+      return synced;
+    }) ?? false
+  );
 }
 
 interface TailSyncBaseline extends SessionRow {
@@ -346,10 +339,14 @@ function applyTailSync(
 
       if (scan.sessionName !== undefined && scan.sessionName !== baseline.sessionName) {
         clearSessionChunksBySourceKind(db, baseline.sessionId, "session_name");
-        if (scan.sessionName) {
+        if (scan.sessionName && scan.sessionNameEntryId) {
           insertTextChunk(db, {
             sessionId: baseline.sessionId,
-            ...createSessionNameChunk(scan.sessionName, baseline.startedAt),
+            ...createSessionNameChunk(
+              scan.sessionName,
+              scan.sessionNameTs ?? baseline.startedAt,
+              scan.sessionNameEntryId,
+            ),
           });
         }
       }
@@ -439,11 +436,6 @@ function writeHookSyncMetadata(db: SessionIndexDatabase, eventType: string): voi
   setMetadata(db, "hook_last_event", eventType);
 }
 
-function readIndexSchemaVersion(db: SessionIndexDatabase): number | undefined {
-  const raw = getMetadata(db, "schema_version");
-  return raw === undefined ? undefined : Number(raw);
-}
-
 function mergeSessionLineage(
   extracted: ExtractedSessionRecord,
   existing: SessionLineageRow | undefined,

package/extensions/session-search/normalize.ts

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-export type FileTouchOp = "changed" | "read" | "touched";
+export type FileTouchOp = "changed" | "read";
 export type FileTouchSource = "tool_call" | "branch_summary_details" | "compaction_details";
 export type PathScope = "absolute" | "relative" | "basename";
 

package/extensions/session-search/reindex.ts

@@ -66,6 +66,7 @@ function dropIndexTables(db: SessionIndexDatabase): void {
   // implicit DELETE that parent-side constraints would reject.
   db.exec(`
     DROP TABLE IF EXISTS session_lineage_relations;
+    DROP TABLE IF EXISTS session_repo_roots;
     DROP TABLE IF EXISTS session_text_chunks;
     DROP TABLE IF EXISTS session_file_touches;
     DROP TABLE IF EXISTS session_text_chunks_fts;

package/extensions/session-search.ts

@@ -1,19 +1,23 @@
 import path from "node:path";
 import type { ExtensionAPI, ExtensionContext, 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 {
   stripSearchSnippetMarkers,
   transformSearchSnippetMatches,
 } from "./shared/search-snippet.ts";
 import {
-  getIndexStatus,
-  INDEX_SCHEMA_VERSION,
-  openIndexDatabase,
+  type ActiveSessionBrokerConnection,
+  getActiveSessionBrokerConnection,
+} from "./shared/session-broker/active.ts";
+import {
   type SearchSessionResult,
   type SearchSessionsParams,
+  type SearchSort,
   type SessionIndexStatus,
+  type SessionSearchEvidence,
   searchSessions,
+  withSessionIndex,
 } from "./shared/session-index/index.ts";
 import { formatSessionTitleOrShortId } from "./shared/session-ui.ts";
 import { loadSettings } from "./shared/settings.ts";
@@ -22,6 +26,7 @@ interface SessionSearchToolParams {
   query?: string;
   files?: {
     touched?: string[];
+    changed?: string[];
   };
   repo?: string;
   cwd?: string;
@@ -29,11 +34,12 @@ interface SessionSearchToolParams {
     after?: string;
     before?: string;
   };
+  sort?: SearchSort;
   limit?: number;
+  live?: boolean;
 }
 
 interface SessionSearchToolDetails {
-  error: boolean;
   params?: SessionSearchToolParams | undefined;
   results: SearchSessionResult[];
   status?: SessionIndexStatus | undefined;
@@ -42,23 +48,32 @@ interface SessionSearchToolDetails {
 const DEFAULT_SESSION_SEARCH_LIMIT = 6;
 const COLLAPSED_RESULT_PREVIEW_ROWS = 6;
 
-export default function sessionSearchExtension(pi: ExtensionAPI): void {
+export interface SessionSearchDeps {
+  getBrokerConnection: () => ActiveSessionBrokerConnection | undefined;
+}
+
+export default function sessionSearchExtension(
+  pi: ExtensionAPI,
+  deps: SessionSearchDeps = {
+    getBrokerConnection: getActiveSessionBrokerConnection,
+  },
+): void {
   const settings = loadSettings();
 
   pi.registerTool({
     name: "session_search",
     label: "Session Search",
-    description: "Search prior Pi sessions",
-    promptSnippet: "Use when you need to locate an earlier session to do a detailed follow-up",
+    description: "Search Pi sessions",
+    promptSnippet: "Use when you need to locate a session to do a detailed follow-up",
     promptGuidelines: [
-      "query is plain text only. Do not use boolean operators like OR/AND, parentheses, regex, or other search syntax",
-      "If you want alternatives, run multiple session_search calls with different queries",
+      "Omit query to list matching sessions chronologically",
       "Once you have the right session id, switch to session_ask for questions about that session",
     ],
     parameters: Type.Object({
       query: Type.Optional(
         Type.String({
-          description: "Free-text terms to match against",
+          description:
+            "Use plain adjacent terms for normal search. Supports quoted phrases, AND/OR/NOT, parentheses, and -term negation when matching needs to be stricter.",
         }),
       ),
       files: Type.Optional(
@@ -66,7 +81,14 @@ export default function sessionSearchExtension(pi: ExtensionAPI): void {
           touched: Type.Optional(
             Type.Array(
               Type.String({
-                description: "File path touched in the session",
+                description: "File path read or changed in the session",
+              }),
+            ),
+          ),
+          changed: Type.Optional(
+            Type.Array(
+              Type.String({
+                description: "File path changed in the session",
               }),
             ),
           ),
@@ -79,23 +101,36 @@ export default function sessionSearchExtension(pi: ExtensionAPI): void {
       ),
       cwd: Type.Optional(
         Type.String({
-          description: "Directory the session was started in",
+          description: "Directory of the session",
         }),
       ),
       time: Type.Optional(
         Type.Object({
           after: Type.Optional(
             Type.String({
-              description: "Inclusive lower bound for session modified time, in ISO format",
+              description: "Inclusive lower bound for the session activity interval, in ISO format",
             }),
           ),
           before: Type.Optional(
             Type.String({
-              description: "Inclusive upper bound for session modified time, in ISO format",
+              description: "Inclusive upper bound for the session activity interval, in ISO format",
             }),
           ),
         }),
       ),
+      sort: Type.Optional(
+        Type.Union(
+          [Type.Literal("relevance"), Type.Literal("modified_desc"), Type.Literal("modified_asc")],
+          {
+            description: "Display order for returned matches",
+          },
+        ),
+      ),
+      live: Type.Optional(
+        Type.Boolean({
+          description: "When true, only return currently active sessions",
+        }),
+      ),
       limit: Type.Optional(
         Type.Number({
           description: "Number of matches to return",
@@ -105,19 +140,10 @@ export default function sessionSearchExtension(pi: ExtensionAPI): void {
     async execute(_toolCallId, params: SessionSearchToolParams, _signal, onUpdate, ctx) {
       const validationError = validateSearchParams(params);
       if (validationError) {
-        const details: SessionSearchToolDetails = {
-          error: true,
-          params,
-          results: [],
-        };
-        return {
-          content: [{ type: "text", text: validationError }],
-          details,
-        };
+        throw new Error(validationError);
       }
 
       const progressDetails: SessionSearchToolDetails = {
-        error: false,
         params,
         results: [],
       };
@@ -127,77 +153,53 @@ export default function sessionSearchExtension(pi: ExtensionAPI): void {
       });
 
       const indexPath = settings.index.path;
-      const status = getIndexStatus(indexPath);
-      if (!status.exists || status.schemaVersion !== INDEX_SCHEMA_VERSION) {
+      const liveSessionIds = params.live
+        ? await getLiveSessionIds(deps.getBrokerConnection)
+        : undefined;
+
+      return withSessionIndex(indexPath, { mode: "read", required: true }, ({ db, status }) => {
+        const results = searchSessions(db, buildSearchParams(params, ctx, liveSessionIds));
         const details: SessionSearchToolDetails = {
-          error: true,
           params,
           status,
-          results: [],
+          results,
         };
         return {
           content: [
             {
-              type: "text",
-              text: `Session index missing or incompatible at ${indexPath}. Run /session-index and press r to rebuild it.`,
+              type: "text" as const,
+              text: formatSearchResultsForModel(details),
             },
           ],
           details,
         };
-      }
-
-      const db = openIndexDatabase(status.dbPath, { create: false });
-      try {
-        const results = searchSessions(db, buildSearchParams(params, ctx));
-
-        if (results.length === 0) {
-          const details: SessionSearchToolDetails = {
-            error: false,
-            params,
-            status,
-            results: [],
-          };
-          return {
-            content: [{ type: "text", text: "No matching sessions found." }],
-            details,
-          };
-        }
-
-        const details: SessionSearchToolDetails = {
-          error: false,
-          params,
-          status,
-          results,
-        };
-        return {
-          content: [{ type: "text", text: formatSearchResults(results) }],
-          details,
-        };
-      } finally {
-        db.close();
-      }
+      });
     },
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderResult(result, { expanded, isPartial }, theme, context) {
       const details = result.details as SessionSearchToolDetails | undefined;
       const content = result.content[0];
       if (content?.type !== "text") {
         return new Text(theme.fg("error", "No search 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", "Searching sessions..."))];
         lines.push(...formatSessionSearchContextLines(details?.params, theme));
         return new Text(lines.join("\n"), 0, 0);
       }
 
-      if (!details || details.error) {
+      if (!details) {
         return new Text(theme.fg("error", content.text), 0, 0);
       }
 
       const lines = formatSessionSearchContextLines(details.params, theme);
       if (details.results.length === 0) {
         if (lines.length > 0) lines.push("");
-        lines.push(theme.fg("warning", content.text));
+        lines.push(theme.fg("warning", "No matching sessions found."));
         return new Text(lines.join("\n"), 0, 0);
       }
 
@@ -213,21 +215,42 @@ export default function sessionSearchExtension(pi: ExtensionAPI): void {
 function buildSearchParams(
   params: SessionSearchToolParams,
   ctx: ExtensionContext,
+  liveSessionIds?: string[] | undefined,
 ): SearchSessionsParams {
   const currentSessionId = ctx.sessionManager.getSessionId();
 
   return {
     query: params.query,
     touched: params.files?.touched,
+    changed: params.files?.changed,
     repo: params.repo,
     cwd: params.cwd,
     after: params.time?.after,
     before: params.time?.before,
+    sort: params.sort,
     limit: params.limit ?? DEFAULT_SESSION_SEARCH_LIMIT,
-    excludeSessionIds: currentSessionId ? [currentSessionId] : undefined,
+    includeSessionIds: liveSessionIds,
+    relativeToSessionId: currentSessionId,
   };
 }
 
+async function getLiveSessionIds(
+  getBrokerConnection: SessionSearchDeps["getBrokerConnection"],
+): Promise<string[]> {
+  const connection = getBrokerConnection();
+  if (!connection) {
+    throw new Error(
+      "Session messaging is not active; live session search requires session messaging.",
+    );
+  }
+
+  try {
+    return await connection.listSessionIds();
+  } catch (error) {
+    throw new Error(`Session messaging is unavailable: ${formatError(error)}`);
+  }
+}
+
 function formatSessionSearchContextLines(
   params: SessionSearchToolParams | undefined,
   theme: Theme,
@@ -242,7 +265,12 @@ function formatSessionSearchContextLines(
   const filters: string[] = [];
   if (params.repo?.trim()) filters.push(`repo: ${params.repo.trim()}`);
   if (params.cwd?.trim()) filters.push(`cwd: ${params.cwd.trim()}`);
-  if (params.files?.touched?.length) filters.push(`files: ${params.files.touched.join(", ")}`);
+  if (params.files?.touched?.length)
+    filters.push(`files.touched: ${params.files.touched.join(", ")}`);
+  if (params.files?.changed?.length)
+    filters.push(`files.changed: ${params.files.changed.join(", ")}`);
+  if (params.live) filters.push("live: true");
+  if (params.sort) filters.push(`sort: ${params.sort}`);
   if (params.time?.after?.trim()) filters.push(`after: ${params.time.after.trim()}`);
   if (params.time?.before?.trim()) filters.push(`before: ${params.time.before.trim()}`);
   if (params.limit !== undefined) filters.push(`limit: ${params.limit}`);
@@ -267,13 +295,16 @@ function formatSessionSearchPanelResults(
   const visibleResults = expanded ? results : results.slice(0, COLLAPSED_RESULT_PREVIEW_ROWS);
   const lines = visibleResults.flatMap((result, index) => {
     const location = formatSearchResultLocation(result.cwd);
-    const heading = `${index + 1}. ${theme.bold(formatSearchResultLabel(result))}${location ? ` ${theme.fg("dim", `(${location})`)}` : ""}`;
-    const snippet = params?.query ? formatSearchSnippet(result) : undefined;
-    return snippet ? [heading, theme.fg("dim", `  - ${snippet}`)] : [heading];
+    const relation = result.relation ? ` ${theme.fg("dim", `[${result.relation}]`)}` : "";
+    const heading = `${index + 1}. ${theme.bold(formatSearchResultLabel(result))}${relation}${location ? ` ${theme.fg("dim", `(${location})`)}` : ""}`;
+    const snippets = params?.query ? formatSearchSnippets(result).slice(0, 3) : [];
+    return snippets.length > 0
+      ? [heading, ...snippets.map((snippet) => theme.fg("dim", `  - ${snippet}`))]
+      : [heading];
   });
 
   if (!expanded && results.length > visibleResults.length) {
-    lines.push(theme.fg("dim", `... ${results.length - visibleResults.length} more`));
+    lines.push(formatOverflowHint(results.length - visibleResults.length, results.length, theme));
   }
 
   return lines;
@@ -289,76 +320,70 @@ function formatSearchResultLocation(cwd: string | undefined): string | undefined
   return base || cwd;
 }
 
-function formatSearchSnippet(result: SearchSessionResult): string | undefined {
-  const plainSnippet = stripSearchSnippetMarkers(result.snippet)?.replace(/\s+/g, " ").trim();
-  if (!plainSnippet) return undefined;
-  if (plainSnippet === result.sessionName || plainSnippet === result.cwd) return undefined;
-  return transformSearchSnippetMatches(result.snippet, (match) => `[${match}]`)
-    ?.replace(/\s+/g, " ")
-    .trim();
+function formatSearchSnippets(result: SearchSessionResult): string[] {
+  return result.evidence
+    .filter((evidence): evidence is SearchTextEvidence => evidence.kind === "text")
+    .map((evidence) => formatSearchSnippetText(evidence.snippet))
+    .filter((snippet): snippet is string => Boolean(snippet));
 }
 
-interface SearchResultTextStyles {
-  cwd: (text: string) => string;
-  primary: (text: string) => string;
-  secondary: (text: string) => string;
+interface SearchTextEvidence {
+  kind: "text";
+  sourceKind: string;
+  snippet: string;
+  score: number;
+  entryId: string;
 }
 
-function formatSearchResults(
-  results: SearchSessionResult[],
-  styles: SearchResultTextStyles = defaultSearchResultTextStyles,
-): string {
-  const groups = new Map<string, SearchSessionResult[]>();
-
-  for (const result of results) {
-    const bucket = groups.get(result.cwd);
-    if (bucket) {
-      bucket.push(result);
-      continue;
-    }
-
-    groups.set(result.cwd, [result]);
-  }
-
-  return [...groups.entries()]
-    .flatMap(([cwd, groupResults], groupIndex) => {
-      const lines = [styles.cwd(`cwd: ${cwd}`)];
-      for (const result of groupResults) {
-        lines.push(...formatSearchResult(result, styles));
-      }
-      if (groupIndex < groups.size - 1) {
-        lines.push("");
-      }
-      return lines;
-    })
-    .join("\n")
+function formatSearchSnippetText(snippet: string): string | undefined {
+  const plainSnippet = stripSearchSnippetMarkers(snippet)?.replace(/\s+/g, " ").trim();
+  if (!plainSnippet) return undefined;
+  return transformSearchSnippetMatches(snippet, (match) => `[${match}]`)
+    ?.replace(/\s+/g, " ")
     .trim();
 }
 
-function formatSearchResult(result: SearchSessionResult, styles: SearchResultTextStyles): string[] {
-  const lines = [styles.primary(`${result.sessionName || "[unnamed]"}: ${result.sessionId}`)];
+function formatSearchResultsForModel(details: SessionSearchToolDetails): string {
+  return JSON.stringify(
+    {
+      params: details.params,
+      status: details.status,
+      results: details.results.map(formatSearchResultForModel),
+    },
+    null,
+    2,
+  );
+}
 
-  if (result.matchedFiles.length > 0) {
-    lines.push(styles.secondary(`matched_files: ${result.matchedFiles.join(", ")}`));
-  }
+function formatSearchResultForModel(result: SearchSessionResult): SearchSessionResult {
+  return {
+    ...result,
+    snippet: stripSearchSnippetMarkers(result.snippet) ?? result.snippet,
+    evidence: result.evidence.map(formatEvidenceForModel),
+  };
+}
 
-  if (result.score > 0 || result.hitCount > 0) {
-    lines.push(styles.secondary(`score: ${result.score.toFixed(2)} / hits: ${result.hitCount}`));
+function formatEvidenceForModel(evidence: SessionSearchEvidence): SessionSearchEvidence {
+  if (evidence.kind !== "text") {
+    return evidence;
   }
 
-  const plainSnippet = stripSearchSnippetMarkers(result.snippet)?.replace(/\s+/g, " ").trim();
-  if (plainSnippet && plainSnippet !== result.sessionName && plainSnippet !== result.cwd) {
-    lines.push(styles.secondary(`snippet: ${plainSnippet}`));
-  }
+  return {
+    ...evidence,
+    snippet: stripSearchSnippetMarkers(evidence.snippet) ?? evidence.snippet,
+  };
+}
 
-  return lines;
+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)")}`;
 }
 
-const defaultSearchResultTextStyles: SearchResultTextStyles = {
-  cwd: (text) => text,
-  primary: (text) => text,
-  secondary: (text) => text,
-};
+function formatKeyHint(keybinding: Keybinding): string {
+  return getKeybindings().getKeys(keybinding).join("/");
+}
 
 function validateSearchParams(params: SessionSearchToolParams): string | undefined {
   if (params.time?.after && !isValidIsoDateLike(params.time.after)) {
@@ -388,3 +413,7 @@ function isValidIsoDateLike(value: string): boolean {
   const date = new Date(value);
   return !Number.isNaN(date.getTime());
 }
+
+function formatError(error: unknown): string {
+  return error instanceof Error && error.message.trim() ? error.message : String(error);
+}

package/extensions/shared/model.ts

@@ -0,0 +1,18 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelReference } from "./settings.ts";
+
+export function findModelByReference(
+  availableModels: Model<Api>[],
+  reference: ModelReference,
+): Model<Api> | undefined {
+  return availableModels.find(
+    (model) => model.provider === reference.provider && model.id === reference.modelId,
+  );
+}
+
+export function resolveConfiguredModel(
+  availableModels: Model<Api>[],
+  configuredModel: ModelReference | undefined,
+): Model<Api> | undefined {
+  return configuredModel ? findModelByReference(availableModels, configuredModel) : undefined;
+}

package/extensions/shared/session-broker/active.ts

@@ -0,0 +1,26 @@
+export interface ActiveSessionBrokerConnection {
+  listSessionIds(): Promise<string[]>;
+}
+
+// Pi loads extension entrypoints through separate jiti module graphs, so module-local
+// singletons are not shared between session-messaging and session-search. The process
+// global is the only way to share a single connection
+const ACTIVE_CONNECTION_KEY = Symbol.for("pi-sessions.active-session-broker-connection");
+
+type ActiveConnectionGlobal = typeof globalThis & {
+  [ACTIVE_CONNECTION_KEY]?: ActiveSessionBrokerConnection | undefined;
+};
+
+function getActiveConnectionGlobal(): ActiveConnectionGlobal {
+  return globalThis as ActiveConnectionGlobal;
+}
+
+export function setActiveSessionBrokerConnection(
+  connection: ActiveSessionBrokerConnection | undefined,
+): void {
+  getActiveConnectionGlobal()[ACTIVE_CONNECTION_KEY] = connection;
+}
+
+export function getActiveSessionBrokerConnection(): ActiveSessionBrokerConnection | undefined {
+  return getActiveConnectionGlobal()[ACTIVE_CONNECTION_KEY];
+}