Merge branch 'tmp-2025-01-11' - resume scope toggle with async loading (#620)

packages/coding-agent/src/core/session-manager.ts

@@ -13,8 +13,9 @@ import {
 	statSync,
 	writeFileSync,
 } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
-import { getAgentDir as getDefaultAgentDir } from "../config.js";
+import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -156,6 +157,8 @@ export interface SessionContext {
 export interface SessionInfo {
 	path: string;
 	id: string;
+	/** Working directory where the session was started. Empty string for old sessions. */
+	cwd: string;
 	created: Date;
 	modified: Date;
 	messageCount: number;
@@ -470,6 +473,118 @@ export function findMostRecentSession(sessionDir: string): string | null {
 	}
 }
 
+function isMessageWithContent(message: AgentMessage): message is Message {
+	return typeof (message as Message).role === "string" && "content" in message;
+}
+
+function extractTextContent(message: Message): string {
+	const content = message.content;
+	if (typeof content === "string") {
+		return content;
+	}
+	return content
+		.filter((block): block is TextContent => block.type === "text")
+		.map((block) => block.text)
+		.join(" ");
+}
+
+async function buildSessionInfo(filePath: string): Promise<SessionInfo | null> {
+	try {
+		const content = await readFile(filePath, "utf8");
+		const entries: FileEntry[] = [];
+		const lines = content.trim().split("\n");
+
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				entries.push(JSON.parse(line) as FileEntry);
+			} catch {
+				// Skip malformed lines
+			}
+		}
+
+		if (entries.length === 0) return null;
+		const header = entries[0];
+		if (header.type !== "session") return null;
+
+		const stats = await stat(filePath);
+		let messageCount = 0;
+		let firstMessage = "";
+		const allMessages: string[] = [];
+
+		for (const entry of entries) {
+			if (entry.type !== "message") continue;
+			messageCount++;
+
+			const message = (entry as SessionMessageEntry).message;
+			if (!isMessageWithContent(message)) continue;
+			if (message.role !== "user" && message.role !== "assistant") continue;
+
+			const textContent = extractTextContent(message);
+			if (!textContent) continue;
+
+			allMessages.push(textContent);
+			if (!firstMessage && message.role === "user") {
+				firstMessage = textContent;
+			}
+		}
+
+		const cwd = typeof (header as SessionHeader).cwd === "string" ? (header as SessionHeader).cwd : "";
+
+		return {
+			path: filePath,
+			id: (header as SessionHeader).id,
+			cwd,
+			created: new Date((header as SessionHeader).timestamp),
+			modified: stats.mtime,
+			messageCount,
+			firstMessage: firstMessage || "(no messages)",
+			allMessagesText: allMessages.join(" "),
+		};
+	} catch {
+		return null;
+	}
+}
+
+export type SessionListProgress = (loaded: number, total: number) => void;
+
+async function listSessionsFromDir(
+	dir: string,
+	onProgress?: SessionListProgress,
+	progressOffset = 0,
+	progressTotal?: number,
+): Promise<SessionInfo[]> {
+	const sessions: SessionInfo[] = [];
+	if (!existsSync(dir)) {
+		return sessions;
+	}
+
+	try {
+		const dirEntries = await readdir(dir);
+		const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f));
+		const total = progressTotal ?? files.length;
+
+		let loaded = 0;
+		const results = await Promise.all(
+			files.map(async (file) => {
+				const info = await buildSessionInfo(file);
+				loaded++;
+				onProgress?.(progressOffset + loaded, total);
+				return info;
+			}),
+		);
+		for (const info of results) {
+			if (info) {
+				sessions.push(info);
+			}
+		}
+	} catch {
+		// Return empty list on error
+	}
+
+	return sessions;
+}
+
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
  *
@@ -1057,88 +1172,69 @@ export class SessionManager {
 	}
 
 	/**
-	 * List all sessions.
+	 * List all sessions for a directory.
 	 * @param cwd Working directory (used to compute default session directory)
 	 * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+	 * @param onProgress Optional callback for progress updates (loaded, total)
 	 */
-	static list(cwd: string, sessionDir?: string): SessionInfo[] {
+	static async list(cwd: string, sessionDir?: string, onProgress?: SessionListProgress): Promise<SessionInfo[]> {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd);
-		const sessions: SessionInfo[] = [];
+		const sessions = await listSessionsFromDir(dir, onProgress);
+		sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+		return sessions;
+	}
+
+	/**
+	 * List all sessions across all project directories.
+	 * @param onProgress Optional callback for progress updates (loaded, total)
+	 */
+	static async listAll(onProgress?: SessionListProgress): Promise<SessionInfo[]> {
+		const sessionsDir = getSessionsDir();
 
 		try {
-			const files = readdirSync(dir)
-				.filter((f) => f.endsWith(".jsonl"))
-				.map((f) => join(dir, f));
+			if (!existsSync(sessionsDir)) {
+				return [];
+			}
+			const entries = await readdir(sessionsDir, { withFileTypes: true });
+			const dirs = entries.filter((e) => e.isDirectory()).map((e) => join(sessionsDir, e.name));
 
-			for (const file of files) {
+			// Count total files first for accurate progress
+			let totalFiles = 0;
+			const dirFiles: string[][] = [];
+			for (const dir of dirs) {
 				try {
-					const content = readFileSync(file, "utf8");
-					const lines = content.trim().split("\n");
-					if (lines.length === 0) continue;
-
-					// Check first line for valid session header
-					let header: { type: string; id: string; timestamp: string } | null = null;
-					try {
-						const first = JSON.parse(lines[0]);
-						if (first.type === "session" && first.id) {
-							header = first;
-						}
-					} catch {
-						// Not valid JSON
-					}
-					if (!header) continue;
-
-					const stats = statSync(file);
-					let messageCount = 0;
-					let firstMessage = "";
-					const allMessages: string[] = [];
-
-					for (let i = 1; i < lines.length; i++) {
-						try {
-							const entry = JSON.parse(lines[i]);
-
-							if (entry.type === "message") {
-								messageCount++;
-
-								if (entry.message.role === "user" || entry.message.role === "assistant") {
-									const textContent = entry.message.content
-										.filter((c: any) => c.type === "text")
-										.map((c: any) => c.text)
-										.join(" ");
-
-									if (textContent) {
-										allMessages.push(textContent);
-
-										if (!firstMessage && entry.message.role === "user") {
-											firstMessage = textContent;
-										}
-									}
-								}
-							}
-						} catch {
-							// Skip malformed lines
-						}
-					}
-
-					sessions.push({
-						path: file,
-						id: header.id,
-						created: new Date(header.timestamp),
-						modified: stats.mtime,
-						messageCount,
-						firstMessage: firstMessage || "(no messages)",
-						allMessagesText: allMessages.join(" "),
-					});
+					const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
+					dirFiles.push(files.map((f) => join(dir, f)));
+					totalFiles += files.length;
 				} catch {
-					// Skip files that can't be read
+					dirFiles.push([]);
+				}
+			}
+
+			// Process all files with progress tracking
+			let loaded = 0;
+			const sessions: SessionInfo[] = [];
+			const allFiles = dirFiles.flat();
+
+			const results = await Promise.all(
+				allFiles.map(async (file) => {
+					const info = await buildSessionInfo(file);
+					loaded++;
+					onProgress?.(loaded, totalFiles);
+					return info;
+				}),
+			);
+
+			for (const info of results) {
+				if (info) {
+					sessions.push(info);
 				}
 			}
 
 			sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+			return sessions;
 		} catch {
-			// Return empty list on error
+			return [];
 		}
-
-		return sessions;
 	}
 }