@vanillagreen/pi-qol 1.2.0 → 1.3.0

package/extensions/qol/session-search/cache.ts

@@ -0,0 +1,273 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { oneLine } from "../ansi.js";
+import {
+	DEFAULT_SESSION_SEARCH_CACHE_TTL_SECONDS,
+	DEFAULT_SESSION_SEARCH_SHORTCUT,
+	SESSION_SEARCH_PENDING_SYMBOL,
+	SESSION_SEARCH_STATUS_KEY,
+} from "../constants.js";
+import { expandHome, piSettingsPaths, settingBoolean, settingNumber, settingString, settingStringAllowEmpty } from "../settings.js";
+import type {
+	QolSessionPaletteAction,
+	QolSessionSearchPendingMessage,
+	QolSessionSearchResult,
+	QolSessionSearchScope,
+	QolSessionSearchSession,
+	QolSessionUserMessage,
+} from "./types.js";
+
+let qolSessionSearchCache: QolSessionSearchSession[] = [];
+let qolSessionSearchLoadedAt = 0;
+let qolSessionSearchLoading: Promise<QolSessionSearchSession[]> | undefined;
+const qolSessionUserMessagesCache = new Map<string, QolSessionUserMessage[]>();
+export const qolSessionSearchPendingActions = new Map<string, QolSessionPaletteAction>();
+let qolSessionSearchPendingActionCounter = 0;
+
+export function nextSessionSearchPendingActionId(): string {
+	return `ss-${Date.now().toString(36)}-${(++qolSessionSearchPendingActionCounter).toString(36)}`;
+}
+
+export function getPendingSessionSearchMessage(): QolSessionSearchPendingMessage | undefined {
+	return (globalThis as unknown as Record<PropertyKey, unknown>)[SESSION_SEARCH_PENDING_SYMBOL] as QolSessionSearchPendingMessage | undefined;
+}
+
+export function setPendingSessionSearchMessage(message: QolSessionSearchPendingMessage | undefined): void {
+	const host = globalThis as unknown as Record<PropertyKey, unknown>;
+	if (message) host[SESSION_SEARCH_PENDING_SYMBOL] = message;
+	else delete host[SESSION_SEARCH_PENDING_SYMBOL];
+}
+
+function coerceDate(value: unknown): Date {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	const date = new Date(typeof value === "string" || typeof value === "number" ? value : 0);
+	return Number.isNaN(date.getTime()) ? new Date(0) : date;
+}
+
+function sessionInfoToSearchSession(info: any): QolSessionSearchSession | undefined {
+	if (!info || typeof info.path !== "string") return undefined;
+	return {
+		allMessagesText: typeof info.allMessagesText === "string" ? info.allMessagesText : "",
+		created: coerceDate(info.created),
+		cwd: typeof info.cwd === "string" ? info.cwd : "",
+		firstMessage: typeof info.firstMessage === "string" ? info.firstMessage : "(no messages)",
+		id: typeof info.id === "string" ? info.id : basename(info.path),
+		messageCount: Number.isFinite(Number(info.messageCount)) ? Number(info.messageCount) : 0,
+		modified: coerceDate(info.modified),
+		name: typeof info.name === "string" && info.name.trim() ? info.name.trim() : undefined,
+		parentSessionPath: typeof info.parentSessionPath === "string" ? info.parentSessionPath : undefined,
+		path: info.path,
+	};
+}
+
+function resolveSettingsRelativePath(value: string, settingsPath: string): string {
+	const expanded = expandHome(value.trim());
+	return isAbsolute(expanded) ? expanded : resolve(dirname(settingsPath), expanded);
+}
+
+export function sessionSearchShortcut(cwd?: string): string | undefined {
+	// Legacy escape hatch from the original ctrl+f setting. If users disabled it,
+	// keep shortcuts disabled even though the default shortcut is now conflict-free.
+	if (!settingBoolean("sessionSearch.ctrlFShortcut", true, cwd)) return undefined;
+	const shortcut = settingStringAllowEmpty("sessionSearch.shortcutKey", DEFAULT_SESSION_SEARCH_SHORTCUT, cwd).trim().toLowerCase();
+	if (!shortcut || shortcut === "none" || shortcut === "off" || shortcut === "false") return undefined;
+	if (shortcut === "f3") return DEFAULT_SESSION_SEARCH_SHORTCUT;
+	return shortcut;
+}
+
+function configuredSessionDir(cwd: string): string | undefined {
+	const envDir = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
+	if (envDir) return resolveSettingsRelativePath(envDir, join(resolve(cwd), ".pi", "settings.json"));
+	let configured: string | undefined;
+	for (const settingsPath of piSettingsPaths(cwd)) {
+		if (!existsSync(settingsPath)) continue;
+		try {
+			const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+			if (typeof parsed?.sessionDir === "string" && parsed.sessionDir.trim()) {
+				configured = resolveSettingsRelativePath(parsed.sessionDir, settingsPath);
+			}
+		} catch {
+			// Ignore malformed optional settings.
+		}
+	}
+	return configured;
+}
+
+function canonicalPathForSessionSearch(path: string | undefined): string | undefined {
+	if (!path) return undefined;
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve(path);
+	}
+}
+
+export function sameSessionSearchProject(sessionCwd: string | undefined, cwd: string): boolean {
+	return canonicalPathForSessionSearch(sessionCwd) === canonicalPathForSessionSearch(cwd);
+}
+
+export function defaultSessionSearchScope(cwd?: string): QolSessionSearchScope {
+	return settingString("sessionSearch.defaultScope", "current", cwd).toLowerCase() === "all" ? "all" : "current";
+}
+
+async function loadQolSessionSearchSessions(ctx: ExtensionContext, onProgress?: (loaded: number, total: number) => void): Promise<QolSessionSearchSession[]> {
+	const customSessionDir = configuredSessionDir(ctx.cwd);
+	const infos = customSessionDir
+		? await SessionManager.list(ctx.cwd, customSessionDir, onProgress)
+		: await SessionManager.listAll(onProgress);
+	return infos.map(sessionInfoToSearchSession).filter((session): session is QolSessionSearchSession => session !== undefined);
+}
+
+export async function refreshQolSessionSearchCache(ctx: ExtensionContext, options?: { force?: boolean; quiet?: boolean }): Promise<QolSessionSearchSession[]> {
+	const ttlMs = Math.max(0, settingNumber("sessionSearch.cacheTtlSeconds", DEFAULT_SESSION_SEARCH_CACHE_TTL_SECONDS, ctx.cwd) * 1000);
+	const fresh = qolSessionSearchCache.length > 0 && (ttlMs === 0 || Date.now() - qolSessionSearchLoadedAt < ttlMs);
+	if (!options?.force && fresh) return qolSessionSearchCache;
+	if (qolSessionSearchLoading) return qolSessionSearchLoading;
+
+	if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, "Loading sessions...");
+	qolSessionSearchLoading = loadQolSessionSearchSessions(ctx, (loaded, total) => {
+		if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, `Loading sessions ${loaded}/${total}`);
+	}).then((sessions) => {
+		qolSessionSearchCache = sessions;
+		qolSessionSearchLoadedAt = Date.now();
+		qolSessionUserMessagesCache.clear();
+		return sessions;
+	}).finally(() => {
+		qolSessionSearchLoading = undefined;
+		if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+	});
+	return qolSessionSearchLoading;
+}
+
+function messageContentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part: any) => {
+		if (part?.type === "text" && typeof part.text === "string") return part.text;
+		if (part?.type === "image") return "[image]";
+		return "";
+	}).filter(Boolean).join(" ");
+}
+
+function sessionMessageTimestamp(entry: any, message: any): number | undefined {
+	if (typeof message?.timestamp === "number" && Number.isFinite(message.timestamp)) return message.timestamp;
+	if (typeof entry?.timestamp === "number" && Number.isFinite(entry.timestamp)) return entry.timestamp;
+	if (typeof entry?.timestamp === "string") {
+		const parsed = new Date(entry.timestamp).getTime();
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return undefined;
+}
+
+export function sessionUserMessages(sessionPath: string): QolSessionUserMessage[] {
+	const cached = qolSessionUserMessagesCache.get(sessionPath);
+	if (cached) return cached;
+	const messages: QolSessionUserMessage[] = [];
+	try {
+		const lines = readFileSync(sessionPath, "utf8").split(/\r?\n/);
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			let entry: any;
+			try { entry = JSON.parse(line); } catch { continue; }
+			const message = entry?.type === "message" ? entry.message : undefined;
+			if (!message || message.role !== "user") continue;
+			const text = oneLine(messageContentText(message.content));
+			if (!text) continue;
+			messages.push({
+				entryId: typeof entry.id === "string" ? entry.id : undefined,
+				index: messages.length + 1,
+				parentId: typeof entry.parentId === "string" || entry.parentId === null ? entry.parentId : undefined,
+				text,
+				timestamp: sessionMessageTimestamp(entry, message),
+			});
+		}
+	} catch {
+		// Ignore unreadable sessions; callers fall back to SessionInfo.firstMessage.
+	}
+	qolSessionUserMessagesCache.set(sessionPath, messages);
+	return messages;
+}
+
+export function userMessagesForResult(result: QolSessionSearchResult): QolSessionUserMessage[] {
+	const messages = sessionUserMessages(result.path);
+	if (messages.length > 0) return messages;
+	return [{ index: 1, text: oneLine(result.firstMessage || "No user messages") }];
+}
+
+export function sessionUserPromptCount(session: QolSessionSearchSession): number {
+	const count = sessionUserMessages(session.path).length;
+	if (count > 0) return count;
+	return session.firstMessage && session.firstMessage !== "(no messages)" ? 1 : 0;
+}
+
+export function promptCountLabel(count: number): string {
+	return `${count} prompt${count === 1 ? "" : "s"}`;
+}
+
+export function lastUserMessageSnippet(session: QolSessionSearchSession): string {
+	const messages = sessionUserMessages(session.path);
+	return messages[messages.length - 1]?.text || oneLine(session.firstMessage || "No user messages");
+}
+
+export function sessionDisplayName(session: QolSessionSearchSession): string {
+	if (session.name) return oneLine(session.name) || "session";
+	if (session.cwd) {
+		const parts = oneLine(session.cwd).split(/[\\/]+/).filter(Boolean);
+		if (parts.length >= 2) return parts.slice(-2).join("/");
+		if (parts.length === 1) return parts[0]!;
+	}
+	return oneLine(basename(session.path) || "session") || "session";
+}
+
+export function sessionResumeTitle(session: QolSessionSearchSession): string {
+	// Match /resume's primary label: explicit session name, otherwise first user prompt.
+	if (session.name) return oneLine(session.name) || sessionDisplayName(session);
+	if (session.firstMessage && session.firstMessage !== "(no messages)") return oneLine(session.firstMessage) || sessionDisplayName(session);
+	return sessionDisplayName(session);
+}
+
+export function shortPathForUi(path: string): string {
+	const cleaned = oneLine(path);
+	const home = homedir();
+	if (cleaned === home) return "~";
+	if (cleaned.startsWith(`${home}/`)) return `~${cleaned.slice(home.length)}`;
+	return cleaned;
+}
+
+export interface QolModelInfo {
+	provider: string;
+	id: string;
+}
+
+export function sessionModelInfo(sessionPath: string): QolModelInfo | undefined {
+	try {
+		const model = SessionManager.open(sessionPath).buildSessionContext().model;
+		if (!model?.provider || !model?.modelId) return undefined;
+		return { provider: model.provider, id: model.modelId };
+	} catch {
+		return undefined;
+	}
+}
+
+export function sameModel(a: QolModelInfo | undefined, b: QolModelInfo | undefined): boolean {
+	return Boolean(a && b && a.provider === b.provider && a.id === b.id);
+}
+
+export function modelLabel(model: QolModelInfo | undefined): string {
+	return model ? `${model.provider}/${model.id}` : "unknown model";
+}
+
+export function pinSessionModel(sessionPath: string, model: NonNullable<ExtensionContext["model"]>, thinkingLevel?: string): void {
+	const manager = SessionManager.open(sessionPath);
+	const context = manager.buildSessionContext();
+	if (context.model?.provider !== model.provider || context.model?.modelId !== model.id) {
+		manager.appendModelChange(model.provider, model.id);
+	}
+	if (thinkingLevel) {
+		const branch = manager.getBranch();
+		const lastThinking = [...branch].reverse().find((entry: any) => entry?.type === "thinking_level_change") as { thinkingLevel?: string } | undefined;
+		if (lastThinking?.thinkingLevel !== thinkingLevel) manager.appendThinkingLevelChange(thinkingLevel as any);
+	}
+}