@ogulcancelik/pi-session-recall 1.0.5 → 1.0.7

package/README.md

@@ -1,6 +1,6 @@
 # pi-session-recall
 
-Recall past [pi](https://github.com/earendil-works/pi) sessions. Search through conversation history and query specific sessions with an LLM.
+Give [pi](https://github.com/earendil-works/pi) access to past conversations. Ask a normal question about previous work, and the agent can find the relevant sessions and inspect them for an answer.
 
 ## Install
 
@@ -16,31 +16,53 @@ Or add manually to `~/.pi/agent/settings.json`:
 }
 ```
 
-## What it does
+## How it works
 
-Two tools that let the agent recall past sessions:
+The extension adds two tools to pi: `session_search` and `session_query`. You do not need to call them yourself. Ask the agent a natural-language question such as:
 
-### `session_search`
+> What did we decide about authentication and security?
 
-Literal text search across all past sessions using ripgrep-style fixed-string matching. It is not semantic search. The agent should search for one distinctive token or exact phrase at a time, such as a filename, package name, error string, function name, issue id, or remembered wording.
+The agent can then:
 
-Spaces mean exact spaces in an exact phrase. For unrelated concepts, the agent should call `session_search` multiple times instead of combining them into one query.
+1. Search for a few distinctive terms or exact phrases across your saved session files.
+2. Review the matching snippets and select the most relevant sessions.
+3. Ask `session_query` a focused question about each selected session.
+4. Combine the answers and respond with the relevant decisions, changes, or context.
 
-### `session_query`
+For example, the tool flow may look like this:
+
+```text
+You: What did we decide about authentication and security?
+Agent: session_search("authentication")
+Agent: session_search("security")
+Agent: session_query(<matching-session>, "What decisions did we make about authentication and security?")
+Agent: <answers your question>
+```
+
+Other useful prompts include:
 
-Deep-dives into a specific session file. Loads the conversation, sends it to an LLM, and answers your question about it.
+- `How did we fix the Cannot find module '@sinclair/typebox' error?`
+- `Which files did we change when we added passkey authentication?`
+- `Find the session where we discussed Blender VAT baking.`
+- `What approach did we reject for token refresh, and why?`
 
-For large sessions that exceed the model's context window, it uses smart windowing: keeps the first/last messages plus keyword-relevant sections, marking gaps with `[... N messages omitted ...]`.
+There is no background indexing or vector database. Recall happens on demand: the main agent searches session JSONL files, then an LLM reads the relevant conversation and answers a focused question.
 
-### `/session-recall`
+### `session_search`
+
+Searches all past sessions using case-insensitive, literal fixed-string matching—essentially `rg -i -F`. It is not regex or semantic search. One call should contain one distinctive token or exact phrase, such as a filename, package name, error string, function name, issue ID, or remembered wording.
+
+Spaces are treated as part of the exact phrase. To search for separate concepts such as authentication and security, the agent makes separate calls rather than searching for `authentication security` as one phrase.
+
+### `session_query`
 
-Command to configure which model is used for `session_query`. Opens a picker with all your available models.
+Loads one selected session and sends its conversation to an LLM with a focused question. It includes user and assistant messages plus tool calls, while omitting assistant thinking and tool results to reduce cost.
 
-By default, queries use your **current session model**. If you want to save tokens, pick a cheaper model (e.g. Haiku, GPT-4o mini).
+For a session larger than the model's context window, it keeps the beginning, end, and sections relevant to the question. Omitted sections are marked with `[... N messages omitted ...]`.
 
 ## Configuration
 
-Config is stored at `~/.pi/agent/session-recall.json`:
+To use a dedicated model for `session_query`, create or edit `~/.pi/agent/session-recall.json`:
 
 ```json
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogulcancelik/pi-session-recall",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Search and query past pi sessions. Recall previous conversations on demand.",
   "type": "module",
   "keywords": [

package/session-recall.ts

@@ -1,9 +1,8 @@
 /**
  * Session Recall Extension - Search and query past pi sessions
  *
- * Two tools + one command:
+ * Two tools:
  *
- * Tools:
  * 1. session_search - Find relevant past sessions by keywords.
  *    Use when the user mentions something from a previous conversation
  *    and you need to find which session it was in.
@@ -13,18 +12,19 @@
  *    specific session, or when you already know the session path
  *    (e.g., from a handoff).
  *
- * Command:
- * /session-recall - Configure the model used for session queries.
- *    Shows all available models and lets you pick one. Persists the
- *    choice to ~/.pi/agent/session-recall.json (or equivalent).
- *
  * Typical flow: user says "remember when we tried X?" →
  *   session_search("X") → find the right session →
  *   session_query(path, "what approach did we take for X?")
  */
 
-import { complete, type Model, type Api, type Message } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	cleanupSessionResources,
+	type Model,
+	type Api,
+	type Message,
+} from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	getAgentDir,
 	SessionManager,
@@ -33,20 +33,12 @@ import {
 	serializeConversation,
 	type SessionEntry,
 } from "@earendil-works/pi-coding-agent";
-import {
-	Container,
-	Input,
-	Markdown,
-	SelectList,
-	type SelectItem,
-	type SelectListTheme,
-	Spacer,
-	Text,
-} from "@earendil-works/pi-tui";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 import { homedir } from "node:os";
 
 // ── Config ───────────────────────────────────────────────────────────────────
@@ -72,19 +64,10 @@ function loadConfig(): SessionRecallConfig {
 	}
 }
 
-function saveConfig(config: SessionRecallConfig): void {
-	const configPath = getConfigPath();
-	const dir = dirname(configPath);
-	if (!existsSync(dir)) {
-		mkdirSync(dir, { recursive: true });
-	}
-	writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-
 /**
  * Resolve the query model from config → fallback to current session model.
  */
-function resolveQueryModel(ctx: ExtensionCommandContext): Model<Api> | undefined {
+function resolveQueryModel(ctx: ExtensionContext): Model<Api> | undefined {
 	const config = loadConfig();
 	if (config.queryModel) {
 		const found = ctx.modelRegistry.find(config.queryModel.provider, config.queryModel.id);
@@ -174,6 +157,63 @@ function estimateTokens(text: string): number {
 	return Math.ceil(text.length / 4);
 }
 
+/** Create a UUIDv7 for Codex request routing, which is unreliable with UUIDv4. */
+function createUuidV7(): string {
+	const bytes = randomBytes(16);
+	const timestamp = BigInt(Date.now());
+
+	bytes[0] = Number((timestamp >> 40n) & 0xffn);
+	bytes[1] = Number((timestamp >> 32n) & 0xffn);
+	bytes[2] = Number((timestamp >> 24n) & 0xffn);
+	bytes[3] = Number((timestamp >> 16n) & 0xffn);
+	bytes[4] = Number((timestamp >> 8n) & 0xffn);
+	bytes[5] = Number(timestamp & 0xffn);
+	bytes[6] = 0x70 | (bytes[6] & 0x0f);
+	bytes[8] = 0x80 | (bytes[8] & 0x3f);
+
+	const hex = bytes.toString("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+async function completeRecallRequest(
+	model: Model<Api>,
+	context: Parameters<typeof complete>[1],
+	options: NonNullable<Parameters<typeof complete>[2]>,
+): ReturnType<typeof complete> {
+	if (model.provider !== "openai-codex") return complete(model, context, options);
+
+	const sessionId = createUuidV7();
+	try {
+		return await complete(model, context, {
+			...options,
+			sessionId,
+			transport: "websocket",
+		});
+	} finally {
+		cleanupSessionResources(sessionId);
+	}
+}
+
+/**
+ * Keep the conversational record and actions while dropping the two largest,
+ * least useful sources of recall context: assistant thinking and tool output.
+ */
+function prepareRecallMessages(messages: Message[]): Message[] {
+	const prepared: Message[] = [];
+
+	for (const message of messages) {
+		if (message.role === "toolResult") continue;
+		if (message.role === "assistant") {
+			const content = message.content.filter((block) => block.type !== "thinking");
+			if (content.length > 0) prepared.push({ ...message, content });
+		} else {
+			prepared.push(message);
+		}
+	}
+
+	return prepared;
+}
+
 /**
  * Extract keywords from a question for matching.
  * Strips common stop words and short words.
@@ -501,168 +541,11 @@ const MAX_SNIPPETS_PER_SESSION = 3;
 // ── Extension ────────────────────────────────────────────────────────────────
 
 export default function sessionRecallExtension(pi: ExtensionAPI) {
-	// ── /session-recall command ────────────────────────────────────────────
-
-	pi.registerCommand("session-recall", {
-		description: "Configure the model used for session queries",
-		handler: async (_args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("Interactive mode required for /session-recall", "warning");
-				return;
-			}
-
-			const config = loadConfig();
-			const available = ctx.modelRegistry.getAvailable();
-
-			if (available.length === 0) {
-				ctx.ui.notify("No models available. Configure API keys first.", "warning");
-				return;
-			}
-
-			const currentKey = config.queryModel
-				? `${config.queryModel.provider}/${config.queryModel.id}`
-				: null;
-
-			// Build select items: session model fallback + all available models
-			const SESSION_MODEL_VALUE = "__session_model__";
-			const items: SelectItem[] = [
-				{
-					value: SESSION_MODEL_VALUE,
-					label: "(use current session model)",
-					description: currentKey === null ? "active" : undefined,
-				},
-				...available.map((m) => {
-					const key = `${m.provider}/${m.id}`;
-					return {
-						value: key,
-						label: key,
-						description: key === currentKey ? "active" : undefined,
-					};
-				}),
-			];
-
-			const choice = await ctx.ui.custom<string | undefined>(
-				(tui, theme, _kb, done) => {
-					const selectTheme: SelectListTheme = {
-						selectedPrefix: (t) => theme.fg("accent", t),
-						selectedText: (t) => theme.fg("accent", t),
-						description: (t) => theme.fg("muted", t),
-						scrollInfo: (t) => theme.fg("muted", t),
-						noMatch: (t) => theme.fg("muted", t),
-					};
-
-					const container = new Container();
-					const title = new Text(
-						theme.bold("Query model for session_query") +
-							theme.fg("muted", "  (type to filter)"),
-						0,
-						0,
-					);
-					const input = new Input();
-					const listSpacer = new Spacer(1);
-					const hint = new Text(
-						theme.fg("muted", "  ↑/↓ navigate · Enter select · Esc cancel"),
-						0,
-						0,
-					);
-
-					// Fuzzy filter: every term must appear somewhere in the label
-					const fuzzyMatch = (label: string, query: string): boolean => {
-						const lower = label.toLowerCase();
-						const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-						return terms.every((term) => lower.includes(term));
-					};
-
-					let list: SelectList;
-
-					const buildList = (filtered: SelectItem[]): SelectList => {
-						const sl = new SelectList(filtered, 10, selectTheme);
-						sl.onSelect = (item) => done(item.value);
-						sl.onCancel = () => done(undefined);
-						return sl;
-					};
-
-					// Initial list with all items, pre-select active
-					list = buildList(items);
-					const activeIdx = items.findIndex(
-						(i) => i.value === (currentKey ?? SESSION_MODEL_VALUE),
-					);
-					if (activeIdx >= 0) list.setSelectedIndex(activeIdx);
-
-					container.addChild(title);
-					container.addChild(new Spacer(1));
-					container.addChild(input);
-					container.addChild(listSpacer);
-					container.addChild(list);
-					container.addChild(new Spacer(1));
-					container.addChild(hint);
-
-					input.onSubmit = () => {
-						const selected = list.getSelectedItem();
-						if (selected) done(selected.value);
-					};
-					input.onEscape = () => done(undefined);
-
-					const rebuildList = () => {
-						const query = input.getValue();
-						const filtered = query
-							? items.filter((item) => fuzzyMatch(item.label, query))
-							: items;
-
-						container.removeChild(list);
-						list = buildList(filtered);
-						// Re-insert list at correct position (after listSpacer)
-						const spacerIdx = container.children.indexOf(listSpacer);
-						container.children.splice(spacerIdx + 1, 0, list);
-						tui.requestRender();
-					};
-
-					container.handleInput = (data: string) => {
-						// Navigation keys go to the select list
-						const isNav =
-							data === "\x1b[A" || // up
-							data === "\x1b[B" || // down
-							data === "\r" || // enter
-							data === "\n";
-
-						if (isNav) {
-							list.handleInput(data);
-						} else if (data === "\x1b" || data === "\x03") {
-							done(undefined);
-						} else {
-							input.handleInput(data);
-							rebuildList();
-						}
-					};
-
-					return container;
-				},
-			);
-
-			if (choice === undefined) return; // cancelled
-
-			if (choice === SESSION_MODEL_VALUE) {
-				delete config.queryModel;
-				saveConfig(config);
-				ctx.ui.notify("Session query will use the current session model", "info");
-			} else {
-				const slashIdx = choice.indexOf("/");
-				if (slashIdx === -1) return;
-
-				const provider = choice.slice(0, slashIdx);
-				const id = choice.slice(slashIdx + 1);
-				config.queryModel = { provider, id };
-				saveConfig(config);
-				ctx.ui.notify(`Session query model set to ${choice}`, "info");
-			}
-		},
-	});
-
 	// ── session_search tool ────────────────────────────────────────────────
 
 	pi.registerTool({
 		name: "session_search",
-		label: (params) => `Session Search: ${params.query}`,
+		label: "Session Search",
 		description:
 			"Find past sessions by literal text search. This is essentially `rg -i -F` over session JSONL files, not semantic search. " +
 			"Use one exact token or phrase. Spaces are exact spaces in an exact phrase, so only use spaces for wording you expect appeared in the session, such as an error message. " +
@@ -792,10 +675,10 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 
 	pi.registerTool({
 		name: "session_query",
-		label: (params) => `Session Query: ${params.question}`,
+		label: "Session Query",
 		description:
 			"Query a specific session file to get detailed information. Use after session_search to dig into a particular session, " +
-			"or when you already have a session path (e.g., from a handoff). Sends the full conversation to an LLM for analysis.",
+			"or when you already have a session path (e.g., from a handoff). Sends the conversation and tool calls, without assistant thinking or tool output, to an LLM for analysis.",
 		renderResult: (result, options, theme) => {
 			const container = new Container();
 			const text = result.content?.[0]?.type === "text" ? result.content[0].text : "";
@@ -892,12 +775,12 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 			if (!queryModel) {
 				return errorResult(
 					"Error: No model available to analyze the session. " +
-						"Configure one with /session-recall or set up API keys.",
+						"Configure queryModel in session-recall.json or set up API keys.",
 				);
 			}
 
 			// Serialize and check if we need windowing
-			const llmMessages = convertToLlm(messages);
+			const llmMessages = prepareRecallMessages(convertToLlm(messages));
 			const fullText = serializeConversation(llmMessages);
 			const fullTokens = estimateTokens(fullText);
 
@@ -945,7 +828,7 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 					timestamp: Date.now(),
 				};
 
-				const response = await complete(
+				const response = await completeRecallRequest(
 					queryModel,
 					{ systemPrompt: QUERY_SYSTEM_PROMPT, messages: [userMessage] },
 					{ apiKey: auth.apiKey, headers: auth.headers, signal },
@@ -960,9 +843,17 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 					};
 				}
 
-				if (response.stopReason === "error" || response.content.length === 0) {
+				if (response.stopReason === "error") {
+					const providerError =
+						response.errorMessage?.trim() || "The provider returned an error without details.";
+					return errorResult(
+						`Error querying ${queryModel.provider}/${queryModel.id}: ${providerError}`,
+					);
+				}
+
+				if (response.content.length === 0) {
 					return errorResult(
-						`Error: LLM returned empty response (${response.stopReason}). Session may be too large even after windowing.`,
+						`Error querying ${queryModel.provider}/${queryModel.id}: LLM returned an empty response.`,
 					);
 				}