opencodekit 0.12.4 → 0.12.6

package/dist/template/.opencode/plugin/sessions.ts

@@ -1,716 +1,250 @@
-import { existsSync, readdirSync } from "fs";
-import { join } from "path";
-import { type Plugin, tool } from "@opencode-ai/plugin";
-import { readFile } from "fs/promises";
-
 /**
- * read-session plugin - AmpCode-style thread context transfer
- *
- * Enables short, focused sessions by allowing cross-session context reads.
- * Similar to AmpCode's read_thread tool.
- *
- * OpenCode Storage Structure:
- * - Sessions: ~/.local/share/opencode/storage/session/<project_hash>/<session_id>.json
- * - Messages: ~/.local/share/opencode/storage/message/<session_id>/msg_*.json
- * - Parts: ~/.local/share/opencode/storage/part/<message_id>/*.json
- * - Diffs: ~/.local/share/opencode/storage/session_diff/<session_id>.json
+ * OpenCode Session Tools
+ * Provides session browsing, searching, and context transfer
  */
 
-// Constants
-const MAX_SESSIONS_TO_SCAN = 50;
-const SEARCH_TIMEOUT_MS = 60000;
-const LIST_TIMEOUT_MS = 30000;
-const READ_TIMEOUT_MS = 30000;
-
-/**
- * Wrap a promise with a timeout
- */
-function withTimeout<T>(
-	promise: Promise<T>,
-	ms: number,
-	operation: string,
-): Promise<T> {
-	return Promise.race([
-		promise,
-		new Promise<T>((_, reject) =>
-			setTimeout(
-				() => reject(new Error(`${operation} timed out after ${ms}ms`)),
-				ms,
-			),
-		),
-	]);
-}
-
-interface SessionMetadata {
-	id: string;
-	title?: string;
-	directory?: string;
-	projectID?: string;
-	time?: {
-		created: number;
-		updated: number;
-	};
-	summary?: any;
-}
-
-interface SessionInfo extends SessionMetadata {
-	messageCount?: number;
-	fileCount?: number;
-}
-
-interface MessagePart {
-	id: string;
-	type: string;
-	text?: string;
-	thinking?: string;
-	tool?: string;
-	input?: unknown;
-	output?: unknown;
-}
-
-interface SearchResult {
-	session_id: string;
-	message_id: string;
-	role: string;
-	excerpt: string;
-	match_count: number;
-	timestamp?: number;
-}
-
-function parseDate(dateStr: string): Date | null {
-	const today = new Date();
-	today.setHours(0, 0, 0, 0);
-
-	if (dateStr === "today") {
-		return today;
-	}
-
-	if (dateStr === "yesterday") {
-		const yesterday = new Date(today);
-		yesterday.setDate(yesterday.getDate() - 1);
-		return yesterday;
-	}
-
-	if (dateStr === "this week") {
-		const weekStart = new Date(today);
-		weekStart.setDate(weekStart.getDate() - weekStart.getDay());
-		return weekStart;
-	}
-
-	// Try parsing ISO date
-	const parsed = new Date(dateStr);
-	if (!Number.isNaN(parsed.getTime())) {
-		return parsed;
-	}
-
-	return null;
-}
-
-export const SessionsPlugin: Plugin = async ({ client, directory }) => {
-	const storageDir = join(
-		process.env.HOME || "",
-		".local/share/opencode/storage",
-	);
-
-	async function getSessionMetadata(
-		sessionId: string,
-	): Promise<SessionMetadata | null> {
-		const sessionDir = join(storageDir, "session");
-		if (!existsSync(sessionDir)) return null;
-
-		// Search all project directories
-		const projectDirs = readdirSync(sessionDir);
-		for (const projectHash of projectDirs) {
-			const sessionFile = join(sessionDir, projectHash, `${sessionId}.json`);
-			if (existsSync(sessionFile)) {
-				const content = await readFile(sessionFile, "utf-8");
-				return JSON.parse(content);
-			}
-		}
-		return null;
-	}
-
-	async function listSessions(
-		projectDir?: string,
-		since?: string,
-		limit = 20,
-	): Promise<SessionInfo[]> {
-		const messageDir = join(storageDir, "message");
-		if (!existsSync(messageDir)) return [];
-
-		const sessionIds = readdirSync(messageDir).filter((f) =>
-			f.startsWith("ses_"),
-		);
-
-		const sessions: SessionInfo[] = [];
-		let sinceDate: Date | null = null;
-
-		if (since) {
-			sinceDate = parseDate(since);
-		}
-
-		for (const sessionId of sessionIds) {
-			const metadata = await getSessionMetadata(sessionId);
-			if (!metadata) continue;
-
-			// Filter by project
-			if (projectDir && metadata.directory !== projectDir) {
-				continue;
-			}
-
-			// Filter by date
-			if (sinceDate && metadata.time) {
-				const sessionDate = new Date(metadata.time.created);
-				if (sessionDate < sinceDate) {
-					continue;
-				}
-			}
-
-			// Get message count
-			const sessionMsgDir = join(messageDir, sessionId);
-			let messageCount = 0;
-			if (existsSync(sessionMsgDir)) {
-				messageCount = readdirSync(sessionMsgDir).filter((f) =>
-					f.endsWith(".json"),
-				).length;
-			}
-
-			// Get file count
-			const diffFile = join(storageDir, "session_diff", `${sessionId}.json`);
-			let fileCount = 0;
-			if (existsSync(diffFile)) {
-				const diffContent = await readFile(diffFile, "utf-8");
-				const diffs = JSON.parse(diffContent);
-				fileCount = diffs.length;
-			}
-
-			sessions.push({
-				...metadata,
-				messageCount,
-				fileCount,
-			});
-		}
-
-		// Sort by time descending
-		sessions.sort((a, b) => {
-			const aTime = a.time?.created || 0;
-			const bTime = b.time?.created || 0;
-			return bTime - aTime;
-		});
-
-		return sessions.slice(0, limit);
-	}
-
-	/**
-	 * Read message parts from part storage
-	 */
-	async function readMessageParts(messageId: string): Promise<MessagePart[]> {
-		const partDir = join(storageDir, "part", messageId);
-		if (!existsSync(partDir)) return [];
-
-		try {
-			const partFiles = readdirSync(partDir).filter((f) => f.endsWith(".json"));
-			const parts = await Promise.all(
-				partFiles.map(async (file) => {
-					try {
-						const content = await readFile(join(partDir, file), "utf-8");
-						return JSON.parse(content) as MessagePart;
-					} catch {
-						return null;
-					}
-				}),
-			);
-			return parts.filter((p): p is MessagePart => p !== null);
-		} catch {
-			return [];
-		}
-	}
-
-	/**
-	 * Extract text content from message parts
-	 */
-	function extractTextFromParts(parts: MessagePart[]): string {
-		return parts
-			.filter((p) => p.type === "text" && p.text)
-			.map((p) => p.text!)
-			.join("\n");
-	}
-
-	/**
-	 * Search within a single session
-	 */
-	async function searchInSession(
-		sessionId: string,
-		query: string,
-		caseSensitive: boolean,
-		maxResults: number,
-	): Promise<SearchResult[]> {
-		const messageDir = join(storageDir, "message", sessionId);
-		if (!existsSync(messageDir)) return [];
-
-		const results: SearchResult[] = [];
-		const searchQuery = caseSensitive ? query : query.toLowerCase();
-
-		try {
-			const messageFiles = readdirSync(messageDir).filter((f) =>
-				f.endsWith(".json"),
-			);
-
-			for (const file of messageFiles) {
-				if (results.length >= maxResults) break;
-
-				try {
-					const content = await readFile(join(messageDir, file), "utf-8");
-					const message = JSON.parse(content);
-					const messageId = message.id || file.replace(".json", "");
-
-					// Read parts for this message
-					const parts = await readMessageParts(messageId);
-					const textContent = extractTextFromParts(parts);
-					const searchText = caseSensitive
-						? textContent
-						: textContent.toLowerCase();
-
-					if (searchText.includes(searchQuery)) {
-						// Count matches
-						const matchCount = searchText.split(searchQuery).length - 1;
-
-						// Extract excerpt (50 chars around first match)
-						const matchIndex = searchText.indexOf(searchQuery);
-						const start = Math.max(0, matchIndex - 25);
-						const end = Math.min(
-							textContent.length,
-							matchIndex + query.length + 25,
-						);
-						const excerpt = textContent.substring(start, end);
-
-						results.push({
-							session_id: sessionId,
-							message_id: messageId,
-							role: message.role || "unknown",
-							excerpt: `...${excerpt}...`,
-							match_count: matchCount,
-							timestamp: message.time?.created,
-						});
-					}
-				} catch {
-					// Skip corrupted message files
-				}
-			}
-		} catch {
-			// Skip inaccessible session directories
-		}
-
-		return results;
-	}
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin/tool";
 
+export const SessionsPlugin: Plugin = async ({ client }) => {
 	return {
 		tool: {
-			summarize_session: tool({
-				description:
-					"Generate an AI summary of a session using the new auto parameter. Useful for quickly understanding what happened in a previous session.",
-				args: {
-					session_id: tool.schema
-						.string()
-						.describe("Session ID to summarize (e.g. 'ses_abc123')"),
-				},
-				async execute(args) {
-					try {
-						// Use compaction model from config: proxypal/gemini-3-flash-preview
-						const result = await client.session.summarize({
-							path: { id: args.session_id },
-							body: {
-								providerID: "proxypal",
-								modelID: "gemini-3-flash-preview",
-							},
-						});
-						return `Session summarized successfully.\n\n${JSON.stringify(result, null, 2)}`;
-					} catch (error) {
-						return `Error summarizing session: ${error instanceof Error ? error.message : String(error)}`;
-					}
-				},
-			}),
-
 			list_sessions: tool({
-				description:
-					"List OpenCode sessions with metadata. Filter by project and date. Use this before read_session to discover available sessions.",
+				description: "List OpenCode sessions with metadata",
 				args: {
-					project: tool.schema
-						.string()
-						.optional()
-						.describe(
-							"Filter by project: 'current' (default), 'all', or absolute path",
-						),
 					since: tool.schema
 						.string()
 						.optional()
 						.describe(
-							"Filter by date: 'today', 'yesterday', 'this week', or ISO date (e.g. '2024-12-10')",
+							"Filter by date (today, yesterday, this week, or ISO date)",
 						),
 					limit: tool.schema
 						.number()
 						.optional()
 						.describe("Max sessions to return (default: 20)"),
 				},
-				async execute(args) {
-					const projectFilter =
-						!args.project || args.project === "current"
-							? directory
-							: args.project === "all"
-								? undefined
-								: args.project;
-
-					try {
-						const sessions = await withTimeout(
-							listSessions(projectFilter, args.since, args.limit || 20),
-							LIST_TIMEOUT_MS,
-							"List sessions",
-						);
-
-						if (sessions.length === 0) {
-							return "No sessions found matching filters.";
+				async execute(args: { since?: string; limit?: number }) {
+					const result = await client.session.list();
+					if (!result.data) return "No sessions found.";
+
+					let sessions = result.data;
+
+					// Filter by date
+					if (args.since) {
+						const sinceDate = parseDate(args.since);
+						if (sinceDate) {
+							sessions = sessions.filter((s) => {
+								const created = s.time?.created
+									? new Date(s.time.created)
+									: null;
+								return created && created >= sinceDate;
+							});
 						}
+					}
 
-						let output = `# Sessions (${sessions.length})\n\n`;
+					// Limit results
+					const limited = sessions.slice(0, args.limit || 20);
 
-						if (projectFilter && projectFilter !== "all") {
-							output += `**Project:** ${projectFilter}\n`;
-						}
-						if (args.since) {
-							output += `**Since:** ${args.since}\n`;
-						}
-						output += "\n";
-
-						sessions.forEach((s, i) => {
-							const date = s.time?.created
-								? new Date(s.time.created).toLocaleString()
-								: "Unknown";
-							const title = s.title || s.id;
-							output += `${i + 1}. **${s.id}**\n`;
-							output += `   Title: ${title}\n`;
-							output += `   Date: ${date}\n`;
-							output += `   Messages: ${s.messageCount || 0}, Files: ${s.fileCount || 0}\n`;
-							if (s.summary && typeof s.summary === "object") {
-								const sumObj = s.summary as any;
-								if (
-									sumObj.additions !== undefined ||
-									sumObj.deletions !== undefined
-								) {
-									output += `   Changes: +${sumObj.additions || 0}/-${sumObj.deletions || 0}\n`;
-								}
-							}
-							output += "\n";
-						});
+					if (limited.length === 0)
+						return "No sessions found matching criteria.";
 
-						return output;
-					} catch (error) {
-						return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
-					}
+					return `# Sessions\n\n${limited
+						.map(
+							(s) =>
+								`**${s.id}** - ${s.title || "Untitled"}\n   Created: ${s.time?.created ? new Date(s.time.created).toLocaleString() : "Unknown"}`,
+						)
+						.join("\n\n")}`;
 				},
 			}),
 
-			search_session: tool({
-				description:
-					"Full-text search across session messages. Returns matching messages with excerpts.",
+			read_session: tool({
+				description: "Read session context for handoff or reference",
 				args: {
-					query: tool.schema.string().describe("Search query"),
-					session_id: tool.schema
+					session_reference: tool.schema
+						.string()
+						.describe("Session ID, or 'last' for most recent session"),
+					focus: tool.schema
 						.string()
 						.optional()
-						.describe("Limit search to specific session ID"),
-					case_sensitive: tool.schema
-						.boolean()
-						.optional()
-						.describe("Case sensitive search (default: false)"),
-					limit: tool.schema
-						.number()
-						.optional()
-						.describe("Max results to return (default: 20)"),
+						.describe("Focus on specific topic (filters messages by keyword)"),
 				},
-				async execute(args) {
-					if (!args.query || args.query.trim().length === 0) {
-						return "Error: Search query cannot be empty.";
+				async execute(args: { session_reference: string; focus?: string }) {
+					let sessionId = args.session_reference;
+
+					// Handle "last" reference
+					if (sessionId === "last") {
+						const sessions = await client.session.list();
+						if (!sessions.data?.length) return "No sessions found.";
+						sessionId = sessions.data[0].id;
 					}
 
-					const caseSensitive = args.case_sensitive ?? false;
-					const limit = args.limit ?? 20;
+					const session = await client.session.get({ path: { id: sessionId } });
+					if (!session.data) return `Session ${sessionId} not found.`;
 
-					try {
-						const searchOperation = async () => {
-							const allResults: SearchResult[] = [];
+					const messages = await client.session.messages({
+						path: { id: sessionId },
+					});
+					const messageData = messages.data;
 
-							if (args.session_id) {
-								// Search specific session
-								const results = await searchInSession(
-									args.session_id,
-									args.query,
-									caseSensitive,
-									limit,
-								);
-								allResults.push(...results);
-							} else {
-								// Search across sessions (limit to MAX_SESSIONS_TO_SCAN)
-								const sessions = await listSessions(
-									directory,
-									undefined,
-									MAX_SESSIONS_TO_SCAN,
-								);
+					if (!messageData) return `No messages found in session ${sessionId}.`;
 
-								for (const session of sessions) {
-									if (allResults.length >= limit) break;
-
-									const results = await searchInSession(
-										session.id,
-										args.query,
-										caseSensitive,
-										limit - allResults.length,
-									);
-									allResults.push(...results);
-								}
-							}
+					let summary = `# Session: ${session.data.title || "Untitled"}\n\n`;
+					summary += `**ID:** ${session.data.id}\n`;
+					summary += `**Created:** ${session.data.time?.created ? new Date(session.data.time.created).toLocaleString() : "Unknown"}\n`;
+					summary += `**Messages:** ${messageData.length}\n\n`;
 
-							return allResults;
-						};
+					// Focus filtering
+					if (args.focus) {
+						summary += `**Focus:** ${args.focus}\n\n`;
+						const focusLower = args.focus.toLowerCase();
 
-						const results = await withTimeout(
-							searchOperation(),
-							SEARCH_TIMEOUT_MS,
-							"Session search",
+						// Filter messages by keyword
+						const relevant = messageData.filter(
+							(m) =>
+								m.info &&
+								JSON.stringify(m.info).toLowerCase().includes(focusLower),
 						);
+						summary += `Found ${relevant.length} relevant messages.\n\n`;
 
-						if (results.length === 0) {
-							return `No matches found for "${args.query}"${args.session_id ? ` in session ${args.session_id}` : ""}.`;
+						relevant.slice(0, 5).forEach((m, i) => {
+							summary += `${i + 1}. **${m.info.role}**: `;
+							const content = extractContent(m.info);
+							summary += `${content.substring(0, 200)}\n\n`;
+						});
+					} else {
+						// Show last 5 user messages
+						const userMessages = messageData.filter(
+							(m) => m.info?.role === "user",
+						);
+						summary += `## Recent User Messages\n\n`;
+						for (let i = 0; i < Math.min(userMessages.length, 5); i++) {
+							const m = userMessages[i];
+							const content = extractContent(m.info);
+							summary += `${i + 1}. ${content.substring(0, 200)}\n`;
 						}
 
-						let output = `# Search Results: "${args.query}"\n\n`;
-						output += `Found ${results.length} match${results.length === 1 ? "" : "es"}`;
-						if (args.session_id) {
-							output += ` in session ${args.session_id}`;
+						// Show last assistant message
+						const assistantMessages = messageData.filter(
+							(m) => m.info?.role === "assistant",
+						);
+						if (assistantMessages.length > 0) {
+							const last = assistantMessages[assistantMessages.length - 1];
+							const lastContent = extractContent(last.info);
+							summary += `\n## Last Assistant Response\n\n${lastContent.substring(0, 500)}\n`;
 						}
-						output += "\n\n";
-
-						results.forEach((r, i) => {
-							output += `${i + 1}. **${r.session_id}** (${r.role})\n`;
-							output += `   Message: ${r.message_id}\n`;
-							output += `   Matches: ${r.match_count}\n`;
-							output += `   Excerpt: ${r.excerpt}\n\n`;
-						});
-
-						return output;
-					} catch (error) {
-						return `Error searching sessions: ${error instanceof Error ? error.message : String(error)}`;
 					}
+
+					return summary;
 				},
 			}),
 
-			read_session: tool({
-				description: `Read context from a previous OpenCode session. Use list_sessions first to discover sessions. Supports project filtering and date-based selection.`,
+			search_session: tool({
+				description: "Full-text search across session messages",
 				args: {
-					session_reference: tool.schema
-						.string()
-						.describe(
-							"Session ID (e.g. 'ses_abc123'), relative ref ('last', 'previous', '2 ago'), or date ('today', 'yesterday')",
-						),
-					project: tool.schema
-						.string()
-						.optional()
-						.describe(
-							"Filter by project: 'current' (default), 'all', or absolute path. Applied when using relative/date references.",
-						),
-					focus: tool.schema
-						.string()
+					query: tool.schema.string().describe("Search query text"),
+					limit: tool.schema
+						.number()
 						.optional()
-						.describe(
-							"Optional: specific aspect to extract (e.g. 'implementation', 'bug findings', 'file changes')",
-						),
+						.describe("Max results (default: 10)"),
 				},
-				async execute(args) {
-					if (!existsSync(storageDir)) {
-						return "Error: OpenCode storage directory not found.";
-					}
+				async execute(args: { query: string; limit?: number }) {
+					const sessions = await client.session.list();
+					const results: string[] = [];
+					let searched = 0;
+					const searchLimit = args.limit || 10;
 
-					let sessionId = args.session_reference;
-					const projectFilter =
-						!args.project || args.project === "current"
-							? directory
-							: args.project === "all"
-								? undefined
-								: args.project;
-
-					// Handle date-based references
-					const parsedDate = parseDate(sessionId);
-					if (parsedDate) {
-						const sessions = await listSessions(projectFilter, sessionId, 1);
-						if (sessions.length === 0) {
-							return `Error: No sessions found for '${sessionId}' in ${projectFilter || "all projects"}`;
-						}
-						sessionId = sessions[0].id;
-					}
-					// Handle relative references
-					else if (sessionId.match(/^(last|previous|\d+\s*(ago|back))$/i)) {
-						const sessions = await listSessions(projectFilter, undefined, 50);
+					if (!sessions.data) return "No sessions found.";
 
-						if (sessions.length === 0) {
-							return `Error: No sessions found in ${projectFilter || "all projects"}`;
-						}
-
-						if (
-							sessionId.toLowerCase() === "last" ||
-							sessionId.toLowerCase() === "previous"
-						) {
-							sessionId = sessions[0].id;
-						} else {
-							const match = sessionId.match(/^(\d+)/);
-							const index = match ? Number.parseInt(match[1]) : 1;
-							if (index >= sessions.length) {
-								return `Error: Only ${sessions.length} sessions available, requested ${index} ago`;
-							}
-							sessionId = sessions[index].id;
-						}
-					}
+					// Search sessions until we find enough results
+					for (const session of sessions.data) {
+						if (results.length >= searchLimit) break;
 
-					// Clean session ID
-					sessionId = sessionId.split("/").pop() || sessionId;
-					if (!sessionId.startsWith("ses_")) {
-						return `Error: Invalid session ID format. Expected 'ses_...' but got '${sessionId}'`;
-					}
+						try {
+							const messages = await client.session.messages({
+								path: { id: session.id },
+							});
+							const messageData = messages.data;
 
-					// Read session metadata, messages, and diffs
-					const messageDir = join(storageDir, "message", sessionId);
-					const diffFile = join(
-						storageDir,
-						"session_diff",
-						`${sessionId}.json`,
-					);
-
-					if (!existsSync(messageDir)) {
-						const available = await listSessions(projectFilter, undefined, 5);
-						const list = available.map((s) => s.id).join("\n");
-						return `Error: Session '${sessionId}' not found.\n\nRecent sessions:\n${list}`;
-					}
+							if (!messageData) continue;
 
-					const metadata = await getSessionMetadata(sessionId);
-
-					// Read all message files
-					const messageFiles = readdirSync(messageDir).filter((f) =>
-						f.endsWith(".json"),
-					);
-					const messages = await Promise.all(
-						messageFiles.map(async (file) => {
-							const content = await readFile(join(messageDir, file), "utf-8");
-							return JSON.parse(content);
-						}),
-					);
-
-					// Read diffs if available
-					let diffs = [];
-					if (existsSync(diffFile)) {
-						const diffContent = await readFile(diffFile, "utf-8");
-						diffs = JSON.parse(diffContent);
-					}
+							const matches = messageData.filter(
+								(m) =>
+									m.info &&
+									JSON.stringify(m.info)
+										.toLowerCase()
+										.includes(args.query.toLowerCase()),
+							);
 
-					// Build summary
-					let summary = `# Session: ${sessionId}\n\n`;
+							if (matches.length > 0) {
+								const excerpt = extractContent(matches[0].info) || "";
+								results.push(
+									`**${session.id}** - ${session.title || "Untitled"}\n   Matches: ${matches.length}\n   Excerpt: ${excerpt.substring(0, 150)}...`,
+								);
+							}
 
-					if (metadata) {
-						summary += `**Title:** ${metadata.title || "Untitled"}\n`;
-						summary += `**Project:** ${metadata.directory || "Unknown"}\n`;
-						if (metadata.time?.created) {
-							summary += `**Date:** ${new Date(metadata.time.created).toLocaleString()}\n`;
+							searched++;
+							if (searched >= 50) break; // Don't search too many sessions
+						} catch (e) {
+							// Skip inaccessible sessions
 						}
-						summary += "\n";
-					}
-
-					// Message analysis
-					const userMessages = messages.filter((m: any) => m.role === "user");
-					const assistantMessages = messages.filter(
-						(m: any) => m.role === "assistant",
-					);
-
-					summary += `**Messages:** ${messages.length} total (${userMessages.length} user, ${assistantMessages.length} assistant)\n`;
-
-					if (diffs.length > 0) {
-						const totalAdditions = diffs.reduce(
-							(sum: number, d: any) => sum + (d.additions || 0),
-							0,
-						);
-						const totalDeletions = diffs.reduce(
-							(sum: number, d: any) => sum + (d.deletions || 0),
-							0,
-						);
-						summary += `**File Changes:** ${diffs.length} files (+${totalAdditions}/-${totalDeletions})\n\n`;
-					} else {
-						summary += "\n";
 					}
 
-					// Focus filtering
-					if (args.focus) {
-						summary += `**Focus:** ${args.focus}\n\n`;
-
-						if (
-							args.focus.toLowerCase().includes("file") ||
-							args.focus.toLowerCase().includes("change") ||
-							args.focus.toLowerCase().includes("diff")
-						) {
-							// Show file changes
-							if (diffs.length > 0) {
-								summary += `## File Changes\n\n`;
-								diffs.slice(0, 10).forEach((diff: any) => {
-									summary += `### ${diff.file}\n`;
-									summary += `+${diff.additions || 0}/-${diff.deletions || 0}\n\n`;
-									if (diff.before || diff.after) {
-										summary += `**Before:** ${(diff.before || "").substring(0, 200)}...\n`;
-										summary += `**After:** ${(diff.after || "").substring(0, 200)}...\n\n`;
-									}
-								});
-							}
-						} else {
-							// Filter messages by keyword
-							const relevant = messages.filter((m: any) =>
-								JSON.stringify(m)
-									.toLowerCase()
-									.includes(args.focus!.toLowerCase()),
-							);
-							summary += `Found ${relevant.length} relevant messages.\n\n`;
-						}
-					} else {
-						// Full summary
-						summary += `## User Messages\n\n`;
-						for (let i = 0; i < Math.min(userMessages.length, 5); i++) {
-							const m = userMessages[i];
-							const messageId = m.id || `msg_${i}`;
-							const parts = await readMessageParts(messageId);
-							const partText = extractTextFromParts(parts);
-							const content =
-								partText || m.summary?.title || m.content || "[No content]";
-							summary += `${i + 1}. ${content.substring(0, 200)}\n`;
-						}
-
-						if (diffs.length > 0) {
-							summary += `\n## Files Modified\n\n`;
-							diffs.slice(0, 10).forEach((diff: any) => {
-								summary += `- ${diff.file} (+${diff.additions || 0}/-${diff.deletions || 0})\n`;
-							});
-						}
+					if (results.length === 0)
+						return `No matches found for "${args.query}" in ${searched} sessions searched.`;
 
-						// Last assistant message
-						if (assistantMessages.length > 0) {
-							const last = assistantMessages[assistantMessages.length - 1];
-							const lastMessageId = last.id || `msg_last`;
-							const lastParts = await readMessageParts(lastMessageId);
-							const lastPartText = extractTextFromParts(lastParts);
-							const lastContent =
-								lastPartText ||
-								last.summary?.body ||
-								last.content ||
-								"[No content]";
-							summary += `\n## Last Assistant Response\n\n${lastContent.substring(0, 500)}\n`;
-						}
-					}
+					return `# Search Results: "${args.query}"\n\n${results.join("\n\n")}`;
+				},
+			}),
 
-					return summary;
+			summarize_session: tool({
+				description: "Generate AI summary of a session",
+				args: {
+					session_id: tool.schema.string().describe("Session ID to summarize"),
+				},
+				async execute(args: { session_id: string }) {
+					// Request summary via OpenCode's summarization
+					await client.session.summarize({
+						path: { id: args.session_id },
+						body: { providerID: "proxypal", modelID: "gemini-3-flash-preview" },
+					});
+
+					return `Summarizing session ${args.session_id}... Summary will be available shortly.`;
 				},
 			}),
 		},
 	};
 };
+
+function parseDate(dateStr: string): Date | null {
+	const today = new Date();
+	today.setHours(0, 0, 0, 0);
+
+	if (dateStr === "today") return today;
+	if (dateStr === "yesterday") {
+		const yesterday = new Date(today);
+		yesterday.setDate(yesterday.getDate() - 1);
+		return yesterday;
+	}
+	if (dateStr === "this week") {
+		const weekStart = new Date(today);
+		weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+		return weekStart;
+	}
+
+	const parsed = new Date(dateStr);
+	if (!Number.isNaN(parsed.getTime())) return parsed;
+
+	return null;
+}
+
+function extractContent(messageInfo: any): string {
+	if (!messageInfo) return "[No info]";
+
+	// Check for summary object
+	if (typeof messageInfo.summary === "object" && messageInfo.summary !== null) {
+		if (messageInfo.summary.title) return messageInfo.summary.title;
+		if (messageInfo.summary.body) return messageInfo.summary.body;
+	}
+
+	return "[No content]";
+}