opencodekit 0.15.21 → 0.16.1

package/dist/template/.opencode/tool/memory-search.ts

@@ -1,8 +1,15 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import {
+	type ObservationType,
+	type SearchIndexResult,
+	checkFTS5Available,
+	searchObservationsFTS,
+} from "../plugin/lib/memory-db";
 
-interface SearchResult {
+// Fallback file-based search for non-SQLite content
+interface FileSearchResult {
 	file: string;
 	matches: { line: number; content: string }[];
 }
@@ -10,7 +17,7 @@ interface SearchResult {
 async function searchDirectory(
 	dir: string,
 	pattern: RegExp,
-	results: SearchResult[],
+	results: FileSearchResult[],
 	baseDir: string,
 ): Promise<void> {
 	try {
@@ -30,14 +37,15 @@ async function searchDirectory(
 				const lines = content.split("\n");
 				const matches: { line: number; content: string }[] = [];
 
-				lines.forEach((line, index) => {
+				for (let index = 0; index < lines.length; index++) {
+					const line = lines[index];
 					if (pattern.test(line)) {
 						matches.push({
 							line: index + 1,
 							content: line.trim().substring(0, 150),
 						});
 					}
-				});
+				}
 
 				if (matches.length > 0) {
 					const relativePath = path.relative(baseDir, fullPath);
@@ -50,11 +58,11 @@ async function searchDirectory(
 	}
 }
 
-async function keywordSearch(
+async function fallbackKeywordSearch(
 	query: string,
 	type: string | undefined,
-	_limit: number,
-): Promise<SearchResult[]> {
+	limit: number,
+): Promise<FileSearchResult[]> {
 	const memoryDir = path.join(process.cwd(), ".opencode/memory");
 	const beadsDir = path.join(process.cwd(), ".beads/artifacts");
 	const globalMemoryDir = path.join(
@@ -72,17 +80,16 @@ async function keywordSearch(
 		pattern = new RegExp(escaped, "i");
 	}
 
-	const results: SearchResult[] = [];
+	const results: FileSearchResult[] = [];
 
 	// Handle type filtering
 	if (type === "beads") {
 		await searchDirectory(beadsDir, pattern, results, beadsDir);
-	} else if (type && type !== "all") {
+	} else if (type && type !== "all" && type !== "observations") {
 		const typeMap: Record<string, string> = {
 			handoffs: "handoffs",
 			research: "research",
 			templates: "_templates",
-			observations: "observations",
 		};
 		const subdir = typeMap[type];
 		if (subdir) {
@@ -96,19 +103,73 @@ async function keywordSearch(
 		await searchDirectory(globalMemoryDir, pattern, results, globalMemoryDir);
 	}
 
-	return results;
+	return results.slice(0, limit);
 }
 
-function formatKeywordResults(
+const TYPE_ICONS: Record<string, string> = {
+	decision: "🎯",
+	bugfix: "🐛",
+	feature: "✨",
+	pattern: "🔄",
+	discovery: "💡",
+	learning: "📚",
+	warning: "⚠️",
+};
+
+function formatCompactIndex(
+	results: SearchIndexResult[],
 	query: string,
-	results: SearchResult[],
+): string {
+	if (results.length === 0) {
+		return `No observations found for "${query}".\n\nTip: Use memory-search without query to see recent observations.`;
+	}
+
+	let output = `# Search Results: "${query}"\n\n`;
+	output += `Found **${results.length}** observation(s). Use \`memory-get\` for full details.\n\n`;
+	output += "| ID | Type | Title | Date |\n";
+	output += "|---|---|---|---|\n";
+
+	for (const result of results) {
+		const icon = TYPE_ICONS[result.type] || "📝";
+		const date = result.created_at.split("T")[0];
+		const title =
+			result.title.length > 50
+				? `${result.title.substring(0, 47)}...`
+				: result.title;
+		output += `| #${result.id} | ${icon} ${result.type} | ${title} | ${date} |\n`;
+	}
+
+	output += "\n## Snippets\n\n";
+	for (const result of results) {
+		const icon = TYPE_ICONS[result.type] || "📝";
+		output += `**#${result.id}** ${icon} ${result.title}\n`;
+		if (result.snippet) {
+			output += `> ${result.snippet}...\n`;
+		}
+		output += "\n";
+	}
+
+	output += "\n---\n";
+	output += `💡 **Next steps:**\n`;
+	output += `- \`memory-get({ ids: "${results
+		.map((r) => r.id)
+		.slice(0, 3)
+		.join(",")}" })\` - Get full details\n`;
+	output += `- \`memory-timeline({ anchor_id: ${results[0].id} })\` - See chronological context\n`;
+
+	return output;
+}
+
+function formatFallbackResults(
+	query: string,
+	results: FileSearchResult[],
 	limit: number,
 ): string {
 	if (results.length === 0) {
-		return `No matches found for "${query}".`;
+		return `No matches found for "${query}" in non-observation files.`;
 	}
 
-	let output = `# Search: "${query}"\n\n`;
+	let output = `# File Search: "${query}"\n\n`;
 	output += `Found ${results.length} file(s) with matches.\n\n`;
 
 	for (const result of results) {
@@ -127,30 +188,72 @@ function formatKeywordResults(
 }
 
 export default tool({
-	description: `Search across all memory files using keywords.
+	description: `Search observations using FTS5 full-text search.
 	
 	Purpose:
-	- Find past decisions, research, or handoffs
-	- Searches: project memory, beads artifacts, and global memory
-	- Returns file paths with matched lines and context
+	- Fast, ranked search across all observations in SQLite
+	- Returns compact index (~50-100 tokens per result) for progressive disclosure
+	- Use memory-get for full details after identifying relevant observations
+	
+	Search modes:
+	- "observations" (default): Search SQLite with FTS5 ranking
+	- "handoffs", "research", "templates": Search specific markdown directories
+	- "beads": Search .beads/artifacts
+	- "all": Search everything (SQLite + markdown files)
 	
 	Example:
-	memory-search({ query: "authentication", type: "all", limit: 10 })`,
+	memory-search({ query: "authentication" })
+	memory-search({ query: "auth", type: "decision", limit: 5 })`,
 	args: {
-		query: tool.schema
-			.string()
-			.describe("Search query: keywords or regex pattern"),
+		query: tool.schema.string().describe("Search query: keywords or phrase"),
 		type: tool.schema
 			.string()
 			.optional()
 			.describe(
-				"Filter by type: 'all' (default), 'handoffs', 'research', 'templates', 'observations', 'beads'",
+				"Filter by observation type (decision, bugfix, feature, pattern, discovery, learning, warning) or search scope (observations, handoffs, research, templates, beads, all)",
 			),
-		limit: tool.schema.number().optional().describe("Max results (default: 5)"),
+		limit: tool.schema
+			.number()
+			.optional()
+			.describe("Max results (default: 10)"),
 	},
 	execute: async (args: { query: string; type?: string; limit?: number }) => {
-		const limit = args.limit || 5;
-		const results = await keywordSearch(args.query, args.type, limit);
-		return formatKeywordResults(args.query, results, limit);
+		const limit = args.limit || 10;
+
+		// Determine if we should use SQLite FTS5 or fallback
+		const observationTypes = [
+			"decision",
+			"bugfix",
+			"feature",
+			"pattern",
+			"discovery",
+			"learning",
+			"warning",
+		];
+		const isObservationType =
+			args.type && observationTypes.includes(args.type.toLowerCase());
+		const isObservationsScope =
+			!args.type || args.type === "observations" || isObservationType;
+
+		// Try SQLite FTS5 for observations
+		if (isObservationsScope && checkFTS5Available()) {
+			try {
+				const obsType = isObservationType
+					? (args.type?.toLowerCase() as ObservationType)
+					: undefined;
+				const results = searchObservationsFTS(args.query, {
+					type: obsType,
+					limit,
+				});
+				return formatCompactIndex(results, args.query);
+			} catch {
+				// FTS5 failed, fall through to file search
+				// Silently fall back to file-based search
+			}
+		}
+
+		// Fallback to file-based search for non-observation types or FTS5 failure
+		const results = await fallbackKeywordSearch(args.query, args.type, limit);
+		return formatFallbackResults(args.query, results, limit);
 	},
 });

package/dist/template/.opencode/tool/memory-timeline.ts

@@ -0,0 +1,105 @@
+import { tool } from "@opencode-ai/plugin";
+import {
+	type SearchIndexResult,
+	getTimelineAroundObservation,
+} from "../plugin/lib/memory-db";
+
+const TYPE_ICONS: Record<string, string> = {
+	decision: "🎯",
+	bugfix: "🐛",
+	feature: "✨",
+	pattern: "🔄",
+	discovery: "💡",
+	learning: "📚",
+	warning: "⚠️",
+};
+
+function formatTimelineResult(
+	anchor: {
+		id: number;
+		type: string;
+		title: string;
+		created_at: string;
+	} | null,
+	before: SearchIndexResult[],
+	after: SearchIndexResult[],
+): string {
+	if (!anchor) {
+		return "Anchor observation not found.";
+	}
+
+	let output = "# Timeline Context\n\n";
+
+	// Before (older observations)
+	if (before.length > 0) {
+		output += "## Earlier Observations\n\n";
+		for (const obs of before) {
+			const icon = TYPE_ICONS[obs.type] || "📝";
+			const date = obs.created_at.split("T")[0];
+			output += `- **#${obs.id}** ${icon} ${obs.title} _(${date})_\n`;
+			if (obs.snippet) {
+				output += `  ${obs.snippet.substring(0, 80)}...\n`;
+			}
+		}
+		output += "\n";
+	}
+
+	// Anchor
+	const anchorIcon = TYPE_ICONS[anchor.type] || "📝";
+	const anchorDate = anchor.created_at.split("T")[0];
+	output += `## ▶ Current: #${anchor.id}\n\n`;
+	output += `${anchorIcon} **${anchor.title}** _(${anchorDate})_\n\n`;
+
+	// After (newer observations)
+	if (after.length > 0) {
+		output += "## Later Observations\n\n";
+		for (const obs of after) {
+			const icon = TYPE_ICONS[obs.type] || "📝";
+			const date = obs.created_at.split("T")[0];
+			output += `- **#${obs.id}** ${icon} ${obs.title} _(${date})_\n`;
+			if (obs.snippet) {
+				output += `  ${obs.snippet.substring(0, 80)}...\n`;
+			}
+		}
+	}
+
+	return output;
+}
+
+export default tool({
+	description: `Get chronological context around an observation.
+	
+	Purpose:
+	- Progressive disclosure: see what was happening before/after a specific observation
+	- Understand decision context over time
+	- Navigate memory timeline
+	
+	Example:
+	memory-timeline({ anchor_id: 42, depth_before: 5, depth_after: 5 })`,
+	args: {
+		anchor_id: tool.schema
+			.number()
+			.describe("ID of the observation to get context around"),
+		depth_before: tool.schema
+			.number()
+			.optional()
+			.describe("Number of earlier observations to include (default: 5)"),
+		depth_after: tool.schema
+			.number()
+			.optional()
+			.describe("Number of later observations to include (default: 5)"),
+	},
+	execute: async (args: {
+		anchor_id: number;
+		depth_before?: number;
+		depth_after?: number;
+	}) => {
+		const { anchor, before, after } = getTimelineAroundObservation(
+			args.anchor_id,
+			args.depth_before ?? 5,
+			args.depth_after ?? 5,
+		);
+
+		return formatTimelineResult(anchor, before, after);
+	},
+});

package/dist/template/.opencode/tool/memory-update.ts

@@ -1,12 +1,11 @@
-import fs from "node:fs/promises";
-import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import { upsertMemoryFile } from "../plugin/lib/memory-db.js";
 
 export default tool({
 	description: `Update memory files with new learnings, progress, or context.
 	
 	Purpose:
-	- Write or append to project memory in .opencode/memory/
+	- Write or append to project memory in SQLite
 	- Supports subdirectories (e.g., 'research/2024-01-topic')
 	- Two modes: 'replace' (overwrite) or 'append' (add to end)
 	
@@ -17,7 +16,7 @@ export default tool({
 		file: tool.schema
 			.string()
 			.describe(
-				"Memory file to update: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic. Use _templates/ for reference only.",
+				"Memory file to update: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic",
 			),
 		content: tool.schema
 			.string()
@@ -31,33 +30,29 @@ export default tool({
 			),
 	},
 	execute: async (args: { file: string; content: string; mode?: string }) => {
-		// Always write to project memory (.opencode/memory/)
-		const memoryDir = path.join(process.cwd(), ".opencode/memory");
+		// Normalize file path: strip existing .md extension
+		const normalizedFile = args.file.replace(/\.md$/i, "");
+		const mode = (args.mode || "replace") as "replace" | "append";
 
-		// Normalize file path: strip existing .md extension, handle subdirectories
-		const normalizedFile = args.file.replace(/\.md$/i, ""); // Remove .md if present
-		const filePath = path.join(memoryDir, `${normalizedFile}.md`);
-		const mode = args.mode || "replace";
+		const timestamp = new Date().toISOString();
+		let finalContent: string;
 
-		try {
-			// Ensure parent directory exists (handles subdirectories)
-			const fileDir = path.dirname(filePath);
-			await fs.mkdir(fileDir, { recursive: true });
-
-			if (mode === "append") {
-				const timestamp = new Date().toISOString();
-				const appendContent = `\n\n---\n**Updated:** ${timestamp}\n\n${args.content}`;
-				await fs.appendFile(filePath, appendContent, "utf-8");
-				return `Successfully appended to ${normalizedFile}.md\n[Written to: ${filePath}]`;
-			}
-			// Replace mode - update timestamp
-			const timestamp = new Date().toISOString();
-			const updatedContent = args.content.replace(
+		if (mode === "append") {
+			finalContent = `\n\n---\n**Updated:** ${timestamp}\n\n${args.content}`;
+		} else {
+			// Replace mode - update timestamp placeholder if present
+			finalContent = args.content.replace(
 				/\*\*Last Updated:\*\* \[Timestamp\]/,
 				`**Last Updated:** ${timestamp}`,
 			);
-			await fs.writeFile(filePath, updatedContent, "utf-8");
-			return `Successfully updated ${normalizedFile}.md\n[Written to: ${filePath}]`;
+		}
+
+		try {
+			// Store in SQLite (single source of truth)
+			upsertMemoryFile(normalizedFile, finalContent, mode);
+
+			const action = mode === "append" ? "Appended to" : "Updated";
+			return `✓ ${action} ${normalizedFile}`;
 		} catch (error) {
 			if (error instanceof Error) {
 				return `Error updating memory: ${error.message}`;