opencodekit 0.16.0 → 0.16.1

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

@@ -0,0 +1,167 @@
+import { tool } from "@opencode-ai/plugin";
+import {
+	archiveOldObservations,
+	checkpointWAL,
+	getDatabaseSizes,
+	getObservationStats,
+	runFullMaintenance,
+	vacuumDatabase,
+} from "../plugin/lib/memory-db.js";
+
+export default tool({
+	description: `Maintain and cleanup the memory system for long-term storage health.
+	
+	Purpose:
+	- Archive old/superseded observations (default: >90 days)
+	- Checkpoint WAL file back to main database
+	- Vacuum database to reclaim space and defragment
+	- Optimize FTS5 search index
+	
+	Operations:
+	- "status": Show current storage stats (default)
+	- "full": Run full maintenance cycle
+	- "archive": Only archive old observations
+	- "checkpoint": Only checkpoint WAL
+	- "vacuum": Only vacuum database
+	
+	Example:
+	memory-maintain({ operation: "status" })
+	memory-maintain({ operation: "full", older_than_days: 60 })
+	memory-maintain({ operation: "archive", dry_run: true })`,
+	args: {
+		operation: tool.schema
+			.string()
+			.optional()
+			.default("status")
+			.describe("Operation: status, full, archive, checkpoint, vacuum"),
+		older_than_days: tool.schema
+			.number()
+			.optional()
+			.default(90)
+			.describe("Archive observations older than this many days (default: 90)"),
+		dry_run: tool.schema
+			.boolean()
+			.optional()
+			.default(false)
+			.describe("Preview changes without executing"),
+	},
+	execute: async (args: {
+		operation?: string;
+		older_than_days?: number;
+		dry_run?: boolean;
+	}) => {
+		const operation = args.operation || "status";
+		const olderThanDays = args.older_than_days ?? 90;
+		const dryRun = args.dry_run ?? false;
+
+		const results: string[] = [];
+
+		// Helper to format bytes
+		const formatBytes = (bytes: number): string => {
+			if (bytes < 1024) return `${bytes} B`;
+			if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+			return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+		};
+
+		// ===== STATUS =====
+		if (operation === "status") {
+			const sizes = getDatabaseSizes();
+			const stats = getObservationStats();
+
+			results.push("## Memory System Status\n");
+			results.push("### Database Size");
+			results.push(`- Main DB: ${formatBytes(sizes.mainDb)}`);
+			results.push(`- WAL file: ${formatBytes(sizes.wal)}`);
+			results.push(`- **Total: ${formatBytes(sizes.total)}**\n`);
+
+			results.push("### Observations");
+			results.push(`- Total: ${stats.total}`);
+			for (const [type, count] of Object.entries(stats)) {
+				if (type !== "total") {
+					results.push(`- ${type}: ${count}`);
+				}
+			}
+
+			// Archive candidates
+			const archiveCandidates = archiveOldObservations({
+				olderThanDays,
+				includeSuperseded: true,
+				dryRun: true,
+			});
+			results.push(`\n### Maintenance Recommendations`);
+			results.push(
+				`- Archive candidates (>${olderThanDays} days): ${archiveCandidates}`,
+			);
+			if (sizes.wal > 1024 * 1024) {
+				results.push(`- WAL checkpoint recommended (WAL > 1MB)`);
+			}
+
+			return results.join("\n");
+		}
+
+		// ===== FULL MAINTENANCE =====
+		if (operation === "full") {
+			results.push(
+				dryRun ? "## Full Maintenance (DRY RUN)\n" : "## Full Maintenance\n",
+			);
+
+			const stats = runFullMaintenance({
+				olderThanDays,
+				includeSuperseded: true,
+				dryRun,
+			});
+
+			results.push(`### Results`);
+			results.push(`- Archived observations: ${stats.archived}`);
+			results.push(`- WAL checkpointed: ${stats.checkpointed ? "Yes" : "No"}`);
+			results.push(`- Database vacuumed: ${stats.vacuumed ? "Yes" : "No"}`);
+			results.push(`- Space before: ${formatBytes(stats.dbSizeBefore)}`);
+			results.push(`- Space after: ${formatBytes(stats.dbSizeAfter)}`);
+			results.push(`- **Freed: ${formatBytes(stats.freedBytes)}**`);
+
+			return results.join("\n");
+		}
+
+		// ===== ARCHIVE ONLY =====
+		if (operation === "archive") {
+			const archived = archiveOldObservations({
+				olderThanDays,
+				includeSuperseded: true,
+				dryRun,
+			});
+
+			if (dryRun) {
+				return `## Archive Preview\n\nWould archive ${archived} observations older than ${olderThanDays} days.\n\nRun without dry_run to execute.`;
+			}
+
+			return `## Archive Complete\n\nArchived ${archived} observations to observations_archive table.`;
+		}
+
+		// ===== CHECKPOINT ONLY =====
+		if (operation === "checkpoint") {
+			if (dryRun) {
+				const sizes = getDatabaseSizes();
+				return `## Checkpoint Preview\n\nWAL size: ${formatBytes(sizes.wal)}\n\nRun without dry_run to checkpoint.`;
+			}
+
+			const result = checkpointWAL();
+			return `## Checkpoint Complete\n\nCheckpointed: ${result.checkpointed ? "Yes" : "No"}\nWAL pages processed: ${result.walSize}`;
+		}
+
+		// ===== VACUUM ONLY =====
+		if (operation === "vacuum") {
+			if (dryRun) {
+				const sizes = getDatabaseSizes();
+				return `## Vacuum Preview\n\nCurrent size: ${formatBytes(sizes.total)}\n\nRun without dry_run to vacuum.`;
+			}
+
+			const before = getDatabaseSizes();
+			const success = vacuumDatabase();
+			const after = getDatabaseSizes();
+
+			return `## Vacuum Complete\n\nSuccess: ${success ? "Yes" : "No"}\nBefore: ${formatBytes(before.total)}\nAfter: ${formatBytes(after.total)}\nFreed: ${formatBytes(before.total - after.total)}`;
+		}
+
+		return `Unknown operation: ${operation}. Use: status, full, archive, checkpoint, vacuum`;
+	},
+});

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

@@ -0,0 +1,319 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import {
+	type ConfidenceLevel,
+	type ObservationInput,
+	type ObservationType,
+	getMemoryDB,
+	rebuildFTS5,
+	storeObservation,
+} from "../plugin/lib/memory-db";
+
+interface ParsedObservation {
+	type: ObservationType;
+	title: string;
+	subtitle?: string;
+	facts: string[];
+	narrative: string;
+	concepts: string[];
+	files_read: string[];
+	files_modified: string[];
+	confidence: ConfidenceLevel;
+	bead_id?: string;
+	supersedes?: string;
+	markdown_file: string;
+	created_at: string;
+	created_at_epoch: number;
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ */
+function parseYAML(yamlContent: string): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+
+	for (const line of yamlContent.split("\n")) {
+		const match = line.match(/^(\w+):\s*(.*)$/);
+		if (match) {
+			const [, key, value] = match;
+			// Handle JSON arrays
+			if (value.startsWith("[")) {
+				try {
+					result[key] = JSON.parse(value);
+				} catch {
+					result[key] = value;
+				}
+			} else if (value === "null" || value === "") {
+				result[key] = null;
+			} else if (value.startsWith('"') && value.endsWith('"')) {
+				result[key] = value.slice(1, -1);
+			} else {
+				result[key] = value;
+			}
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Extract structured facts from narrative (bullet points).
+ */
+function extractFacts(narrative: string): string[] {
+	const facts: string[] = [];
+	const lines = narrative.split("\n");
+
+	for (const line of lines) {
+		const bulletMatch = line.match(/^[-*]\s+(.+)$/);
+		if (bulletMatch) {
+			facts.push(bulletMatch[1].trim());
+		}
+	}
+
+	return facts;
+}
+
+/**
+ * Parse a markdown observation file into structured data.
+ */
+function parseMarkdownObservation(
+	content: string,
+	filename: string,
+): ParsedObservation {
+	// Parse YAML frontmatter
+	const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+	if (!frontmatterMatch) {
+		throw new Error(`Invalid format: ${filename} - no YAML frontmatter`);
+	}
+
+	const yaml = parseYAML(frontmatterMatch[1]);
+	const narrative = frontmatterMatch[2].trim();
+
+	// Extract title from markdown heading
+	const titleMatch = narrative.match(/^#\s+.+?\s+(.+)$/m);
+	const title = titleMatch
+		? titleMatch[1]
+		: (yaml.title as string) || "Untitled";
+
+	// Validate type
+	const validTypes: ObservationType[] = [
+		"decision",
+		"bugfix",
+		"feature",
+		"pattern",
+		"discovery",
+		"learning",
+		"warning",
+	];
+	const type = (yaml.type as string)?.toLowerCase() as ObservationType;
+	if (!validTypes.includes(type)) {
+		throw new Error(`Invalid type '${yaml.type}' in ${filename}`);
+	}
+
+	// Validate confidence
+	const validConfidence: ConfidenceLevel[] = ["high", "medium", "low"];
+	const confidence = ((yaml.confidence as string)?.toLowerCase() ||
+		"high") as ConfidenceLevel;
+	if (!validConfidence.includes(confidence)) {
+		throw new Error(`Invalid confidence '${yaml.confidence}' in ${filename}`);
+	}
+
+	// Parse created date
+	const createdStr = yaml.created as string;
+	if (!createdStr) {
+		throw new Error(`Missing created date in ${filename}`);
+	}
+	const createdAt = new Date(createdStr);
+	if (Number.isNaN(createdAt.getTime())) {
+		throw new Error(`Invalid created date '${createdStr}' in ${filename}`);
+	}
+
+	// Extract facts from narrative
+	const facts = extractFacts(narrative);
+
+	// Parse files array
+	const files = (yaml.files as string[]) || [];
+
+	return {
+		type,
+		title,
+		subtitle: yaml.subtitle as string | undefined,
+		facts,
+		narrative,
+		concepts: (yaml.concepts as string[]) || [],
+		files_read: files, // Assume all files were read for migration
+		files_modified: files, // Assume all files were modified for migration
+		confidence,
+		bead_id: yaml.bead_id as string | undefined,
+		supersedes: yaml.supersedes as string | undefined,
+		markdown_file: filename,
+		created_at: createdAt.toISOString(),
+		created_at_epoch: createdAt.getTime(),
+	};
+}
+
+export default tool({
+	description: `Migrate existing markdown observations to SQLite database.
+	
+	Purpose:
+	- Import existing .opencode/memory/observations/*.md files into SQLite
+	- Preserves all metadata and content
+	- Creates FTS5 index for fast search
+	- Safe to run multiple times (skips already migrated files)
+	
+	Example:
+	memory-migrate({ dry_run: true })  // Preview migration
+	memory-migrate({})                  // Run migration`,
+	args: {
+		dry_run: tool.schema
+			.boolean()
+			.optional()
+			.describe("Preview migration without writing to database"),
+		force: tool.schema
+			.boolean()
+			.optional()
+			.describe("Force re-migration of all files"),
+	},
+	execute: async (args: { dry_run?: boolean; force?: boolean }) => {
+		const obsDir = path.join(process.cwd(), ".opencode/memory/observations");
+		const migrationMarker = path.join(obsDir, ".migrated");
+
+		// Check for existing migration
+		if (!args.force) {
+			try {
+				await fs.access(migrationMarker);
+				const markerContent = await fs.readFile(migrationMarker, "utf-8");
+				return `Migration already complete.\n\n${markerContent}\n\nUse force: true to re-migrate.`;
+			} catch {
+				// No marker, proceed with migration
+			}
+		}
+
+		// Get all markdown files
+		let files: string[];
+		try {
+			const entries = await fs.readdir(obsDir);
+			files = entries.filter((f) => f.endsWith(".md") && !f.startsWith("."));
+		} catch {
+			return "No observations directory found at .opencode/memory/observations/";
+		}
+
+		if (files.length === 0) {
+			return "No markdown files found to migrate.";
+		}
+
+		// Initialize database
+		const db = getMemoryDB();
+
+		// Parse and migrate
+		const results: {
+			migrated: string[];
+			skipped: string[];
+			errors: { file: string; error: string }[];
+		} = {
+			migrated: [],
+			skipped: [],
+			errors: [],
+		};
+
+		// Sort by filename (which includes date) for chronological order
+		files.sort();
+
+		for (const file of files) {
+			try {
+				const content = await fs.readFile(path.join(obsDir, file), "utf-8");
+				const parsed = parseMarkdownObservation(content, file);
+
+				if (args.dry_run) {
+					results.migrated.push(
+						`${file} → ${parsed.type}: ${parsed.title.substring(0, 50)}`,
+					);
+					continue;
+				}
+
+				// Check if already migrated (by markdown_file)
+				const existing = db
+					.query("SELECT id FROM observations WHERE markdown_file = ?")
+					.get(file);
+
+				if (existing && !args.force) {
+					results.skipped.push(file);
+					continue;
+				}
+
+				// Store observation
+				const input: ObservationInput = {
+					type: parsed.type,
+					title: parsed.title,
+					subtitle: parsed.subtitle,
+					facts: parsed.facts,
+					narrative: parsed.narrative,
+					concepts: parsed.concepts,
+					files_read: parsed.files_read,
+					files_modified: parsed.files_modified,
+					confidence: parsed.confidence,
+					bead_id: parsed.bead_id,
+					markdown_file: file,
+				};
+
+				storeObservation(input);
+				results.migrated.push(file);
+			} catch (e) {
+				results.errors.push({
+					file,
+					error: e instanceof Error ? e.message : String(e),
+				});
+			}
+		}
+
+		// Rebuild FTS5 index after migration
+		if (!args.dry_run && results.migrated.length > 0) {
+			try {
+				rebuildFTS5();
+			} catch {
+				// FTS5 rebuild failed, continue
+			}
+		}
+
+		// Write migration marker
+		if (!args.dry_run) {
+			const markerContent = [
+				`Migrated ${results.migrated.length} observations on ${new Date().toISOString()}`,
+				`Skipped: ${results.skipped.length}`,
+				`Errors: ${results.errors.length}`,
+			].join("\n");
+			await fs.writeFile(migrationMarker, markerContent, "utf-8");
+		}
+
+		// Format output
+		let output = args.dry_run
+			? "# Migration Preview (Dry Run)\n\n"
+			: "# Migration Complete\n\n";
+
+		output += `**Total files**: ${files.length}\n`;
+		output += `**Migrated**: ${results.migrated.length}\n`;
+		output += `**Skipped**: ${results.skipped.length}\n`;
+		output += `**Errors**: ${results.errors.length}\n\n`;
+
+		if (results.errors.length > 0) {
+			output += "## Errors\n\n";
+			for (const { file, error } of results.errors) {
+				output += `- **${file}**: ${error}\n`;
+			}
+			output += "\n";
+		}
+
+		if (args.dry_run && results.migrated.length > 0) {
+			output += "## Files to migrate\n\n";
+			for (const item of results.migrated.slice(0, 20)) {
+				output += `- ${item}\n`;
+			}
+			if (results.migrated.length > 20) {
+				output += `- ... and ${results.migrated.length - 20} more\n`;
+			}
+		}
+
+		return output;
+	},
+});

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

@@ -1,24 +1,23 @@
-import fs from "node:fs/promises";
-import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import { getMemoryFile } from "../plugin/lib/memory-db.js";
 
 export default tool({
 	description: `Read memory files for persistent cross-session context.
 	
 	Purpose:
 	- Retrieve project state, learnings, and active tasks
-	- Checks locations in priority order: project → global → legacy
-	- Supports subdirectories: handoffs/, research/, observations/, _templates/
+	- Reads from SQLite database
+	- Supports subdirectories: handoffs/, research/
 	
 	Example:
 	memory-read({ file: "handoffs/2024-01-20-phase-1" })
-	memory-read({ file: "_templates/task-prd" })`,
+	memory-read({ file: "research/2024-01-topic" })`,
 	args: {
 		file: tool.schema
 			.string()
 			.optional()
 			.describe(
-				"Memory file to read: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic, _templates/task-prd, _templates/task-spec, _templates/task-review, _templates/research, _templates/handoff",
+				"Memory file to read: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic",
 			),
 	},
 	execute: async (args: { file?: string }) => {
@@ -27,48 +26,20 @@ export default tool({
 		// Normalize: strip .md extension if present
 		const normalizedFile = fileName.replace(/\.md$/i, "");
 
-		// Location priority: project > global > legacy
-		const locations = [
-			path.join(process.cwd(), ".opencode/memory", `${normalizedFile}.md`),
-			path.join(
-				process.env.HOME || "",
-				".config/opencode/memory",
-				`${normalizedFile}.md`,
-			),
-			path.join(
-				process.cwd(),
-				".config/opencode/memory",
-				`${normalizedFile}.md`,
-			),
-		];
-
-		// Try each location in order
-		for (const filePath of locations) {
-			try {
-				const content = await fs.readFile(filePath, "utf-8");
-				const locationLabel = filePath.includes(".opencode/memory")
-					? "project"
-					: filePath.includes(process.env.HOME || "")
-						? "global"
-						: "legacy";
-				return `[Read from ${locationLabel}: ${filePath}]\n\n${content}`;
-			} catch (error) {
-				// Continue to next location if file not found
-				if (
-					error instanceof Error &&
-					"code" in error &&
-					error.code === "ENOENT"
-				) {
-					continue;
-				}
-				// Other errors should be reported
-				if (error instanceof Error) {
-					return `Error reading memory from ${filePath}: ${error.message}`;
-				}
+		try {
+			const dbRecord = getMemoryFile(normalizedFile);
+			if (dbRecord) {
+				const updatedInfo = dbRecord.updated_at
+					? ` (updated: ${dbRecord.updated_at})`
+					: "";
+				return `[${normalizedFile}${updatedInfo}]\n\n${dbRecord.content}`;
+			}
+		} catch (error) {
+			if (error instanceof Error) {
+				return `Error reading memory: ${error.message}`;
 			}
 		}
 
-		// No file found in any location
-		return `Memory file '${normalizedFile}.md' not found in any location.\nSearched:\n- ${locations.join("\n- ")}\n\nStructure:\n- handoffs/YYYY-MM-DD-phase (phase transitions)\n- research/YYYY-MM-DD-topic (research findings)\n- _templates/ (prd, spec, review, research, handoff)`;
+		return `Memory file '${normalizedFile}' not found.\n\nStructure:\n- handoffs/YYYY-MM-DD-phase (phase transitions)\n- research/YYYY-MM-DD-topic (research findings)`;
 	},
 });