@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/src/memory/capture.ts

@@ -1,39 +1,19 @@
-/**
- * Memory capture handlers.
- *
- * Event capture remains a supporting path for project incidents and decisions.
- * Explicit user preference capture happens on the chat.message hook where the
- * actual outbound user-authored text parts are available.
- *
- * @module
- */
-
 import type { Database } from "bun:sqlite";
 import { basename } from "node:path";
+import { getLogger } from "../logging/domains";
 import { resolveProjectIdentity } from "../projects/resolve";
+import * as captureUtils from "./capture-utils";
 import { pruneStaleObservations } from "./decay";
 import { insertObservation, upsertPreferenceRecord, upsertProject } from "./repository";
 import type { ObservationType } from "./types";
 
-/**
- * Dependencies for the memory capture handlers.
- */
+const logger = getLogger("memory", "capture");
+
 export interface MemoryCaptureDeps {
 	readonly getDb: () => Database;
 	readonly projectRoot: string;
 }
 
-interface PreferenceCandidate {
-	readonly key: string;
-	readonly value: string;
-	readonly scope: "global" | "project";
-	readonly confidence: number;
-	readonly statement: string;
-}
-
-/**
- * Events that produce supporting observations.
- */
 const CAPTURE_EVENT_TYPES = new Set([
 	"session.created",
 	"session.deleted",
@@ -42,158 +22,6 @@ const CAPTURE_EVENT_TYPES = new Set([
 	"app.phase_transition",
 ]);
 
-const PROJECT_SCOPE_HINTS = [
-	"in this repo",
-	"for this repo",
-	"in this project",
-	"for this project",
-	"in this codebase",
-	"for this codebase",
-	"here ",
-	"this repo ",
-	"this project ",
-] as const;
-
-const EXPLICIT_PREFERENCE_PATTERNS = [
-	{
-		regex: /\b(?:please|do|always|generally)\s+(?:use|prefer|keep|run|avoid)\s+(.+?)(?:[.!?]|$)/i,
-		buildValue: (match: RegExpMatchArray) => match[1]?.trim() ?? "",
-	},
-	{
-		regex: /\b(?:i|we)\s+(?:prefer|want|need|like)\s+(.+?)(?:[.!?]|$)/i,
-		buildValue: (match: RegExpMatchArray) => match[1]?.trim() ?? "",
-	},
-	{
-		regex: /\b(?:don't|do not|never)\s+(.+?)(?:[.!?]|$)/i,
-		buildValue: (match: RegExpMatchArray) => `avoid ${match[1]?.trim() ?? ""}`,
-	},
-] as const;
-
-/**
- * Extracts a session ID from event properties.
- * Supports properties.sessionID, properties.info.id, properties.info.sessionID.
- */
-function extractSessionId(properties: Record<string, unknown>): string | undefined {
-	if (typeof properties.sessionID === "string") return properties.sessionID;
-	if (properties.info !== null && typeof properties.info === "object") {
-		const info = properties.info as Record<string, unknown>;
-		if (typeof info.sessionID === "string") return info.sessionID;
-		if (typeof info.id === "string") return info.id;
-	}
-	return undefined;
-}
-
-function normalizePreferenceKey(value: string): string {
-	const normalized = value
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, " ")
-		.trim()
-		.split(/\s+/)
-		.slice(0, 6)
-		.join(".");
-	return normalized.length > 0 ? normalized : "user.preference";
-}
-
-function normalizePreferenceValue(value: string): string {
-	return value
-		.replace(/\s+/g, " ")
-		.trim()
-		.replace(/[.!?]+$/, "");
-}
-
-function inferPreferenceScope(text: string): "global" | "project" {
-	const lowerText = text.toLowerCase();
-	return PROJECT_SCOPE_HINTS.some((hint) => lowerText.includes(hint)) ? "project" : "global";
-}
-
-function extractTextPartContent(part: unknown): string | null {
-	if (part === null || typeof part !== "object") {
-		return null;
-	}
-
-	const record = part as Record<string, unknown>;
-	if (record.type !== "text") {
-		return null;
-	}
-
-	if (typeof record.text === "string" && record.text.trim().length > 0) {
-		return record.text;
-	}
-	if (typeof record.content === "string" && record.content.trim().length > 0) {
-		return record.content;
-	}
-
-	return null;
-}
-
-function extractExplicitPreferenceCandidates(
-	parts: readonly unknown[],
-): readonly PreferenceCandidate[] {
-	const joinedText = parts
-		.map(extractTextPartContent)
-		.filter((value): value is string => value !== null)
-		.join("\n")
-		.trim();
-	if (joinedText.length === 0) {
-		return Object.freeze([]);
-	}
-
-	const candidates: PreferenceCandidate[] = [];
-	const scope = inferPreferenceScope(joinedText);
-	const lines = joinedText
-		.split(/\n+/)
-		.flatMap((line) => line.split(/(?<=[.!?])\s+/))
-		.map((line) => line.trim())
-		.filter((line) => line.length > 0 && line.length <= 500);
-
-	for (const line of lines) {
-		for (const pattern of EXPLICIT_PREFERENCE_PATTERNS) {
-			const match = line.match(pattern.regex);
-			if (!match) {
-				continue;
-			}
-
-			const value = normalizePreferenceValue(pattern.buildValue(match));
-			if (value.length < 6) {
-				continue;
-			}
-
-			candidates.push(
-				Object.freeze({
-					key: normalizePreferenceKey(value),
-					value,
-					scope,
-					confidence: 0.9,
-					statement: line,
-				}),
-			);
-			break;
-		}
-	}
-
-	const seen = new Set<string>();
-	return Object.freeze(
-		candidates.filter((candidate) => {
-			const uniqueness = `${candidate.scope}:${candidate.key}:${candidate.value}`;
-			if (seen.has(uniqueness)) {
-				return false;
-			}
-			seen.add(uniqueness);
-			return true;
-		}),
-	);
-}
-
-/**
- * Safely truncate a string to maxLen characters.
- */
-function truncate(s: string, maxLen: number): string {
-	return s.length > maxLen ? s.slice(0, maxLen) : s;
-}
-
-/**
- * Creates an event capture handler matching the plugin event hook signature.
- */
 export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 	let currentSessionId: string | null = null;
 	let currentProjectKey: string | null = null;
@@ -214,7 +42,7 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 					sessionId: currentSessionId,
 					type,
 					content,
-					summary: truncate(summary, 200),
+					summary: captureUtils.truncate(summary, 200),
 					confidence,
 					accessCount: 0,
 					createdAt: now(),
@@ -223,7 +51,7 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				deps.getDb(),
 			);
 		} catch (err) {
-			console.warn("[opencode-autopilot] memory capture failed:", err);
+			logger.warn("memory capture failed", { error: String(err) });
 		}
 	}
 
@@ -265,7 +93,7 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 						deps.getDb(),
 					);
 				} catch (err) {
-					console.warn("[opencode-autopilot] upsertProject failed:", err);
+					logger.warn("upsertProject failed", { error: String(err) });
 				}
 				return;
 			}
@@ -282,7 +110,7 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 						try {
 							pruneStaleObservations(projectKey, db);
 						} catch (err) {
-							console.warn("[opencode-autopilot] pruneStaleObservations failed:", err);
+							logger.warn("pruneStaleObservations failed", { error: String(err) });
 						}
 					});
 				}
@@ -290,21 +118,21 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 			}
 
 			case "session.error": {
-				const sessionId = extractSessionId(properties);
+				const sessionId = captureUtils.extractSessionId(properties);
 				if (!sessionId || sessionId !== currentSessionId) return;
 
 				const error = properties.error as Record<string, unknown> | undefined;
 				const errorType = typeof error?.type === "string" ? error.type : "unknown";
 				const message = typeof error?.message === "string" ? error.message : "Unknown error";
 				const content = `${errorType}: ${message}`;
-				const summary = truncate(message, 200);
+				const summary = captureUtils.truncate(message, 200);
 
 				safeInsert("error", content, summary, 0.7);
 				return;
 			}
 
 			case "app.decision": {
-				const sessionId = extractSessionId(properties);
+				const sessionId = captureUtils.extractSessionId(properties);
 				if (!sessionId || sessionId !== currentSessionId) return;
 
 				const decision = typeof properties.decision === "string" ? properties.decision : "";
@@ -312,12 +140,12 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 
 				if (!decision) return;
 
-				safeInsert("decision", decision, rationale || truncate(decision, 200), 0.8);
+				safeInsert("decision", decision, rationale || captureUtils.truncate(decision, 200), 0.8);
 				return;
 			}
 
 			case "app.phase_transition": {
-				const sessionId = extractSessionId(properties);
+				const sessionId = captureUtils.extractSessionId(properties);
 				if (!sessionId || sessionId !== currentSessionId) return;
 
 				const fromPhase =
@@ -335,16 +163,13 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 	};
 }
 
-/**
- * Creates a chat.message capture handler that records explicit user preferences.
- */
 export function createMemoryChatMessageHandler(deps: MemoryCaptureDeps) {
 	return async (
 		input: { readonly sessionID: string },
 		output: { readonly parts: unknown[] },
 	): Promise<void> => {
 		try {
-			const candidates = extractExplicitPreferenceCandidates(output.parts);
+			const candidates = captureUtils.extractExplicitPreferenceCandidates(output.parts);
 			if (candidates.length === 0) {
 				return;
 			}
@@ -392,15 +217,9 @@ export function createMemoryChatMessageHandler(deps: MemoryCaptureDeps) {
 				);
 			}
 		} catch (err) {
-			console.warn("[opencode-autopilot] explicit preference capture failed:", err);
+			logger.warn("explicit preference capture failed", { error: String(err) });
 		}
 	};
 }
 
-export const memoryCaptureInternals = Object.freeze({
-	extractExplicitPreferenceCandidates,
-	extractTextPartContent,
-	inferPreferenceScope,
-	normalizePreferenceKey,
-	normalizePreferenceValue,
-});
+export { captureUtils as memoryCaptureInternals };

package/src/memory/decay.ts

@@ -10,6 +10,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+import { systemTimeProvider, type TimeProvider } from "../scoring/time-provider";
 import {
 	DEFAULT_HALF_LIFE_DAYS,
 	MAX_OBSERVATIONS_PER_PROJECT,
@@ -35,8 +36,9 @@ export function computeRelevanceScore(
 	accessCount: number,
 	type: ObservationType,
 	halfLifeDays: number = DEFAULT_HALF_LIFE_DAYS,
+	timeProvider: TimeProvider = systemTimeProvider,
 ): number {
-	const ageMs = Date.now() - new Date(lastAccessed).getTime();
+	const ageMs = timeProvider.now() - new Date(lastAccessed).getTime();
 	const ageDays = ageMs / MS_PER_DAY;
 	const timeDecay = Math.exp(-ageDays / halfLifeDays);
 	const frequencyWeight = Math.max(Math.log2(accessCount + 1), 1);
@@ -55,6 +57,7 @@ export function computeRelevanceScore(
 export function pruneStaleObservations(
 	projectId: string | null,
 	db?: Database,
+	timeProvider: TimeProvider = systemTimeProvider,
 ): { readonly pruned: number } {
 	const fetchLimit = MAX_OBSERVATIONS_PER_PROJECT + 1000;
 	const observations = getObservationsByProject(projectId, fetchLimit, db);
@@ -64,7 +67,13 @@ export function pruneStaleObservations(
 		.filter((obs): obs is typeof obs & { id: number } => obs.id !== undefined)
 		.map((obs) => ({
 			id: obs.id,
-			score: computeRelevanceScore(obs.lastAccessed, obs.accessCount, obs.type),
+			score: computeRelevanceScore(
+				obs.lastAccessed,
+				obs.accessCount,
+				obs.type,
+				DEFAULT_HALF_LIFE_DAYS,
+				timeProvider,
+			),
 		}));
 
 	let pruned = 0;

package/src/memory/injector.ts

@@ -11,8 +11,11 @@
  */
 
 import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
 import { retrieveMemoryContext } from "./retrieval";
 
+const logger = getLogger("memory", "injector");
+
 /**
  * Configuration for creating a memory injector.
  */
@@ -79,7 +82,7 @@ export function createMemoryInjector(config: MemoryInjectorConfig) {
 				output.system.push(context);
 			}
 		} catch (err) {
-			console.warn("[opencode-autopilot] memory injection failed:", err);
+			logger.warn("memory injection failed", { error: String(err) });
 		}
 	};
 }

package/src/memory/lessons.ts

@@ -0,0 +1,85 @@
+/**
+ * Lesson repository operations.
+ * Handles retrieval of extracted lessons from past runs.
+ */
+
+import type { Database } from "bun:sqlite";
+import { lessonMemorySchema } from "../orchestrator/lesson-schemas";
+import type { Lesson } from "../orchestrator/lesson-types";
+import { getMemoryDb } from "./database";
+
+function resolveDb(db?: Database): Database {
+	return db ?? getMemoryDb();
+}
+
+function tableExists(db: Database, tableName: string): boolean {
+	const row = db
+		.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+		.get(tableName) as { name?: string } | null;
+	return row?.name === tableName;
+}
+
+interface ProjectLessonRow {
+	readonly content: string;
+	readonly domain: Lesson["domain"];
+	readonly extracted_at: string;
+	readonly source_phase: Lesson["sourcePhase"];
+	readonly last_updated_at: string | null;
+}
+
+function listLegacyLessons(projectId: string, db: Database): readonly Lesson[] {
+	if (!tableExists(db, "project_lesson_memory")) {
+		return Object.freeze([]);
+	}
+
+	const row = db
+		.query("SELECT state_json FROM project_lesson_memory WHERE project_id = ?")
+		.get(projectId) as { state_json?: string } | null;
+	if (row?.state_json === undefined) {
+		return Object.freeze([]);
+	}
+
+	try {
+		const parsed = lessonMemorySchema.parse(JSON.parse(row.state_json));
+		return Object.freeze(parsed.lessons);
+	} catch {
+		return Object.freeze([]);
+	}
+}
+
+function buildLessonsFromRows(rows: readonly ProjectLessonRow[]): readonly Lesson[] {
+	return Object.freeze(
+		rows.map((row) =>
+			Object.freeze({
+				content: row.content,
+				domain: row.domain,
+				extractedAt: row.extracted_at,
+				sourcePhase: row.source_phase,
+			}),
+		),
+	);
+}
+
+export function listRelevantLessons(
+	projectId: string,
+	limit = 5,
+	db?: Database,
+): readonly Lesson[] {
+	const d = resolveDb(db);
+	if (tableExists(d, "project_lessons")) {
+		const rows = d
+			.query(
+				`SELECT content, domain, extracted_at, source_phase, last_updated_at
+				 FROM project_lessons
+				 WHERE project_id = ?
+				 ORDER BY extracted_at DESC, lesson_id DESC
+				 LIMIT ?`,
+			)
+			.all(projectId, limit) as ProjectLessonRow[];
+		if (rows.length > 0) {
+			return buildLessonsFromRows(rows);
+		}
+	}
+
+	return listLegacyLessons(projectId, d).slice(0, limit);
+}

package/src/memory/observations.ts

@@ -0,0 +1,177 @@
+/**
+ * Observation repository operations.
+ *
+ * Handles observation CRUD, search, and access tracking.
+ * Extracted from repository.ts for better module organization.
+ *
+ * @module
+ */
+
+import type { Database } from "bun:sqlite";
+import { withTransaction } from "../kernel/transaction";
+import { OBSERVATION_TYPES } from "./constants";
+import { getMemoryDb } from "./database";
+import { observationSchema } from "./schemas";
+import type { Observation, ObservationType } from "./types";
+
+/** Resolve optional db parameter to singleton fallback. */
+function resolveDb(db?: Database): Database {
+	return db ?? getMemoryDb();
+}
+
+/** Validate observation type at runtime. */
+function parseObservationType(value: unknown): ObservationType {
+	if (typeof value === "string" && (OBSERVATION_TYPES as readonly string[]).includes(value)) {
+		return value as ObservationType;
+	}
+	return "context";
+}
+
+/** Map a snake_case DB row to camelCase Observation. */
+function rowToObservation(row: Record<string, unknown>): Observation {
+	return {
+		id: row.id as number,
+		projectId: (row.project_id as string) ?? null,
+		sessionId: row.session_id as string,
+		type: parseObservationType(row.type),
+		content: row.content as string,
+		summary: row.summary as string,
+		confidence: row.confidence as number,
+		accessCount: row.access_count as number,
+		createdAt: row.created_at as string,
+		lastAccessed: row.last_accessed as string,
+	};
+}
+
+/**
+ * Insert an observation. Validates via Zod before writing.
+ * Returns the observation with the generated id.
+ */
+export function insertObservation(obs: Omit<Observation, "id">, db?: Database): Observation {
+	const validated = observationSchema.omit({ id: true }).parse(obs);
+	const d = resolveDb(db);
+
+	return withTransaction(d, () => {
+		const row = d
+			.query<
+				{ id: number },
+				[string | null, string, ObservationType, string, string, number, number, string, string]
+			>(
+				`INSERT INTO observations (project_id, session_id, type, content, summary, confidence, access_count, created_at, last_accessed)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id`,
+			)
+			.get(
+				validated.projectId,
+				validated.sessionId,
+				validated.type,
+				validated.content,
+				validated.summary,
+				validated.confidence,
+				validated.accessCount,
+				validated.createdAt,
+				validated.lastAccessed,
+			);
+
+		if (!row) {
+			throw new Error("Failed to insert observation");
+		}
+
+		return { ...validated, id: row.id };
+	});
+}
+
+/**
+ * Search observations using FTS5 MATCH with BM25 ranking.
+ * Filters by projectId (null for user-level observations).
+ */
+export function searchObservations(
+	query: string,
+	projectId: string | null,
+	limit = 20,
+	db?: Database,
+): Array<Observation & { ftsRank: number }> {
+	const d = resolveDb(db);
+
+	const projectFilter = projectId === null ? "AND o.project_id IS NULL" : "AND o.project_id = ?";
+	const safeFtsQuery = `"${query.replace(/"/g, '""')}"`;
+	const params: Array<string | number> =
+		projectId === null ? [safeFtsQuery, limit] : [safeFtsQuery, projectId, limit];
+
+	const rows = d
+		.query(
+			`SELECT o.*, bm25(observations_fts) as fts_rank
+			 FROM observations_fts f
+			 JOIN observations o ON o.id = f.rowid
+			 WHERE observations_fts MATCH ?
+			   ${projectFilter}
+			 ORDER BY fts_rank
+			 LIMIT ?`,
+		)
+		.all(...params) as Array<Record<string, unknown>>;
+
+	return rows.map((row) => ({
+		...rowToObservation(row),
+		ftsRank: row.fts_rank as number,
+	}));
+}
+
+/**
+ * Get observations filtered by project_id, ordered by created_at DESC.
+ */
+export function getObservationsByProject(
+	projectId: string | null,
+	limit = 50,
+	db?: Database,
+): readonly Observation[] {
+	const d = resolveDb(db);
+
+	const whereClause = projectId === null ? "WHERE project_id IS NULL" : "WHERE project_id = ?";
+	const params: Array<string | number> = projectId === null ? [limit] : [projectId, limit];
+
+	const rows = d
+		.query(`SELECT * FROM observations ${whereClause} ORDER BY created_at DESC LIMIT ?`)
+		.all(...params) as Array<Record<string, unknown>>;
+
+	return rows.map(rowToObservation);
+}
+
+/**
+ * Get recent failure observations for a project.
+ */
+export function getRecentFailureObservations(
+	projectId: string,
+	limit = 5,
+	db?: Database,
+): readonly Observation[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT *
+			 FROM observations
+			 WHERE project_id = ?
+			   AND type = 'error'
+			 ORDER BY created_at DESC, id DESC
+			 LIMIT ?`,
+		)
+		.all(projectId, limit) as Array<Record<string, unknown>>;
+	return Object.freeze(rows.map(rowToObservation));
+}
+
+/**
+ * Delete an observation by id.
+ */
+export function deleteObservation(id: number, db?: Database): void {
+	const d = resolveDb(db);
+	d.run("DELETE FROM observations WHERE id = ?", [id]);
+}
+
+/**
+ * Increment access_count and update last_accessed for an observation.
+ */
+export function updateAccessCount(id: number, db?: Database): void {
+	const d = resolveDb(db);
+	d.run("UPDATE observations SET access_count = access_count + 1, last_accessed = ? WHERE id = ?", [
+		new Date().toISOString(),
+		id,
+	]);
+}