opencodekit 0.0.1

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

@@ -0,0 +1,88 @@
+/**
+ * OpenCode Notification Plugin
+ * Sends native notifications when sessions complete
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+export const NotificationPlugin: Plugin = async ({ client, $ }) => {
+  // Log plugin initialization
+  client.app
+    .log({
+      body: {
+        service: "notification-plugin",
+        level: "info",
+        message: "🔔 Notification Plugin loaded",
+      },
+    })
+    .catch(() => {});
+
+  return {
+    event: async ({ event }) => {
+      // Send notification on session completion
+      if (event.type === "session.idle") {
+        const sessionId = event.properties?.sessionID;
+
+        // Get session summary with simple retry
+        setTimeout(async () => {
+          try {
+            let summary = "Session completed";
+
+            // Try to fetch session summary
+            const messagesResponse = await client.session.messages({
+              path: { id: sessionId },
+            });
+
+            if (messagesResponse.data && Array.isArray(messagesResponse.data)) {
+              const lastUserMessage = messagesResponse.data
+                .filter((m) => m.info.role === "user")
+                .pop();
+
+              // Type guard for summary object
+              const messageSummary = lastUserMessage?.info?.summary;
+              if (
+                messageSummary &&
+                typeof messageSummary === "object" &&
+                messageSummary !== null
+              ) {
+                if ("body" in messageSummary && messageSummary.body) {
+                  summary = String(messageSummary.body).trim().slice(0, 100);
+                } else if ("title" in messageSummary && messageSummary.title) {
+                  summary = String(messageSummary.title).trim();
+                }
+              }
+            }
+
+            // Send notification
+            if (process.platform === "darwin") {
+              const script = `display notification "${summary.replace(/"/g, '\\"')}" with title "OpenCode"`;
+              await $`osascript -e ${script}`;
+            } else {
+              await $`notify-send "OpenCode" ${summary}`;
+            }
+
+            client.app
+              .log({
+                body: {
+                  service: "notification-plugin",
+                  level: "info",
+                  message: `✅ Notification sent: ${summary}`,
+                },
+              })
+              .catch(() => {});
+          } catch (error) {
+            client.app
+              .log({
+                body: {
+                  service: "notification-plugin",
+                  level: "warn",
+                  message: `⚠️ Notification failed: ${(error as Error).message}`,
+                },
+              })
+              .catch(() => {});
+          }
+        }, 2000);
+      }
+    },
+  };
+};

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

@@ -0,0 +1,434 @@
+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
+ * - Diffs: ~/.local/share/opencode/storage/session_diff/<session_id>.json
+ */
+
+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;
+}
+
+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 ({ 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);
+	}
+
+	return {
+		tool: {
+			list_sessions: tool({
+				description:
+					"List OpenCode sessions with metadata. Filter by project and date. Use this before read_session to discover available sessions.",
+				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')",
+						),
+					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;
+
+					const sessions = await listSessions(
+						projectFilter,
+						args.since,
+						args.limit || 20,
+					);
+
+					if (sessions.length === 0) {
+						return "No sessions found matching filters.";
+					}
+
+					let output = `# Sessions (${sessions.length})\n\n`;
+
+					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";
+					});
+
+					return output;
+				},
+			}),
+
+			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.`,
+				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()
+						.optional()
+						.describe(
+							"Optional: specific aspect to extract (e.g. 'implementation', 'bug findings', 'file changes')",
+						),
+				},
+				async execute(args) {
+					if (!existsSync(storageDir)) {
+						return "Error: OpenCode storage directory not found.";
+					}
+
+					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.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;
+						}
+					}
+
+					// Clean session ID
+					sessionId = sessionId.split("/").pop() || sessionId;
+					if (!sessionId.startsWith("ses_")) {
+						return `Error: Invalid session ID format. Expected 'ses_...' but got '${sessionId}'`;
+					}
+
+					// 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}`;
+					}
+
+					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);
+					}
+
+					// Build summary
+					let summary = `# Session: ${sessionId}\n\n`;
+
+					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`;
+						}
+						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`;
+						userMessages.slice(0, 5).forEach((m: any, i: number) => {
+							const content = 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`;
+							});
+						}
+
+						// Last assistant message
+						if (assistantMessages.length > 0) {
+							const last = assistantMessages[assistantMessages.length - 1];
+							const lastContent =
+								last.summary?.body || last.content || "[No content]";
+							summary += `\n## Last Assistant Response\n\n${lastContent.substring(0, 500)}\n`;
+						}
+					}
+
+					return summary;
+				},
+			}),
+		},
+	};
+};