opencodekit 0.11.1 → 0.12.1

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

@@ -12,9 +12,35 @@ import { readFile } from "fs/promises";
  * 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
  */
 
+// 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;
@@ -32,6 +58,25 @@ interface SessionInfo extends SessionMetadata {
 	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);
@@ -156,6 +201,109 @@ export const SessionsPlugin: Plugin = async ({ client, directory }) => {
 		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;
+	}
+
 	return {
 		tool: {
 			summarize_session: tool({
@@ -212,48 +360,146 @@ export const SessionsPlugin: Plugin = async ({ client, directory }) => {
 								? undefined
 								: args.project;
 
-					const sessions = await listSessions(
-						projectFilter,
-						args.since,
-						args.limit || 20,
-					);
+					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.";
-					}
+						if (sessions.length === 0) {
+							return "No sessions found matching filters.";
+						}
 
-					let output = `# Sessions (${sessions.length})\n\n`;
+						let output = `# Sessions (${sessions.length})\n\n`;
 
-					if (projectFilter && projectFilter !== "all") {
-						output += `**Project:** ${projectFilter}\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;
+					} catch (error) {
+						return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
 					}
-					if (args.since) {
-						output += `**Since:** ${args.since}\n`;
+				},
+			}),
+
+			search_session: tool({
+				description:
+					"Full-text search across session messages. Returns matching messages with excerpts.",
+				args: {
+					query: tool.schema.string().describe("Search query"),
+					session_id: 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)"),
+				},
+				async execute(args) {
+					if (!args.query || args.query.trim().length === 0) {
+						return "Error: Search query cannot be empty.";
 					}
-					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`;
+
+					const caseSensitive = args.case_sensitive ?? false;
+					const limit = args.limit ?? 20;
+
+					try {
+						const searchOperation = async () => {
+							const allResults: SearchResult[] = [];
+
+							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,
+								);
+
+								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);
+								}
 							}
+
+							return allResults;
+						};
+
+						const results = await withTimeout(
+							searchOperation(),
+							SEARCH_TIMEOUT_MS,
+							"Session search",
+						);
+
+						if (results.length === 0) {
+							return `No matches found for "${args.query}"${args.session_id ? ` in session ${args.session_id}` : ""}.`;
 						}
-						output += "\n";
-					});
 
-					return output;
+						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}`;
+						}
+						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)}`;
+					}
 				},
 			}),
 
@@ -430,10 +676,15 @@ export const SessionsPlugin: Plugin = async ({ client, directory }) => {
 					} 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]";
+						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`;
@@ -445,8 +696,14 @@ export const SessionsPlugin: Plugin = async ({ client, directory }) => {
 						// 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 =
-								last.summary?.body || last.content || "[No content]";
+								lastPartText ||
+								last.summary?.body ||
+								last.content ||
+								"[No content]";
 							summary += `\n## Last Assistant Response\n\n${lastContent.substring(0, 500)}\n`;
 						}
 					}

package/dist/template/.opencode/skill/beads/SKILL.md

@@ -129,10 +129,6 @@ bd_ls({ status: "all", limit: 20 });
 // See ready work (unblocked tasks)
 bd_ready();
 // Returns tasks where all dependencies are closed
-
-// See execution plan with parallel tracks
-bd_plan();
-// Groups ready tasks by priority
 ```
 
 ## Session Start Protocol
@@ -354,29 +350,21 @@ bd_status({ include_agents: true });
 
 Shows ready tasks, in-progress count, active locks, agent info.
 
-### Find Bottlenecks
-
-```typescript
-bd_insights();
-```
-
-Returns blocked tasks, high-priority keystones, dependency analysis.
-
-### Priority Recommendations
+### Find Blocked Work
 
 ```typescript
-bd_priority({ limit: 5 });
+bd_blocked();
 ```
 
-Suggests what to work on next based on priority and dependencies.
+Returns tasks that have unresolved dependencies.
 
-### Execution Plan
+### View Dependencies
 
 ```typescript
-bd_plan();
+bd_dep({ action: "tree", child: "<task-id>", type: "blocks" });
 ```
 
-Groups ready tasks by priority into parallel execution tracks.
+Shows dependency tree for a specific task.
 
 ## Git Sync
 

package/dist/template/.opencode/skill/beads/references/DEPENDENCIES.md

@@ -4,7 +4,7 @@ Beads supports task dependencies for ordering work.
 
 ## Overview
 
-Dependencies affect what work is "ready" - tasks with unmet dependencies won't appear in `bd_claim()` or `bd_priority()`.
+Dependencies affect what work is "ready" - tasks with unmet dependencies won't appear in `bd_claim()` results.
 
 ## Creating Dependencies
 
@@ -125,6 +125,6 @@ bd_add({ title: "API", deps: ["task:tests"] })  // API depends on tests?
 bd_show({ id: "task-abc" });
 // Shows what blocks this task and what this task blocks
 
-bd_insights();
-// Shows bottlenecks and blocked work across project
+bd_blocked();
+// Shows all blocked tasks across project
 ```

package/dist/template/.opencode/skill/beads/references/WORKFLOWS.md

@@ -138,7 +138,7 @@ Session Start with in_progress:
 ```
 Unblocking:
 - [ ] bd_ls({ status: "open" }) to see all tasks
-- [ ] bd_insights() to find bottlenecks
+- [ ] bd_blocked() to find blocked tasks
 - [ ] Identify blocker tasks
 - [ ] Work on blockers first
 - [ ] Closing blocker unblocks dependent work

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.11.1",
+	"version": "0.12.1",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"type": "module",
 	"repository": {