@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/memory/database.ts

@@ -1,8 +1,8 @@
 import { Database } from "bun:sqlite";
 import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { getGlobalConfigDir } from "../utils/paths";
-import { DB_FILE, MEMORY_DIR } from "./constants";
+import { dirname } from "node:path";
+import { runProjectRegistryMigrations } from "../projects/database";
+import { getAutopilotDbPath } from "../utils/paths";
 
 let db: Database | null = null;
 
@@ -11,12 +11,7 @@ let db: Database | null = null;
  * Idempotent via IF NOT EXISTS.
  */
 export function initMemoryDb(database: Database): void {
-	database.run(`CREATE TABLE IF NOT EXISTS projects (
-		id TEXT PRIMARY KEY,
-		path TEXT NOT NULL UNIQUE,
-		name TEXT NOT NULL,
-		last_updated TEXT NOT NULL
-	)`);
+	runProjectRegistryMigrations(database);
 
 	database.run(`CREATE TABLE IF NOT EXISTS observations (
 		id INTEGER PRIMARY KEY,
@@ -42,6 +37,73 @@ export function initMemoryDb(database: Database): void {
 		last_updated TEXT NOT NULL
 	)`);
 
+	database.run(`CREATE TABLE IF NOT EXISTS preference_records (
+		id TEXT PRIMARY KEY,
+		key TEXT NOT NULL,
+		value TEXT NOT NULL,
+		scope TEXT NOT NULL CHECK(scope IN ('global', 'project')),
+		project_id TEXT,
+		status TEXT NOT NULL CHECK(status IN ('candidate', 'confirmed', 'rejected')) DEFAULT 'confirmed',
+		confidence REAL NOT NULL DEFAULT 0.5,
+		source_session TEXT,
+		created_at TEXT NOT NULL,
+		last_updated TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id),
+		UNIQUE(key, scope, project_id)
+	)`);
+
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_records_scope_updated
+		ON preference_records(scope, last_updated DESC, key ASC)`);
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_records_project_updated
+		ON preference_records(project_id, last_updated DESC, key ASC)`);
+
+	database.run(`CREATE TABLE IF NOT EXISTS preference_evidence (
+		id TEXT PRIMARY KEY,
+		preference_id TEXT NOT NULL,
+		session_id TEXT,
+		run_id TEXT,
+		statement TEXT NOT NULL,
+		statement_hash TEXT NOT NULL,
+		confidence REAL NOT NULL DEFAULT 0.5,
+		confirmed INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL,
+		FOREIGN KEY (preference_id) REFERENCES preference_records(id) ON DELETE CASCADE,
+		UNIQUE(preference_id, statement_hash)
+	)`);
+
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_evidence_preference_created
+		ON preference_evidence(preference_id, created_at DESC, id DESC)`);
+
+	database.run(`INSERT INTO preference_records (
+		id,
+		key,
+		value,
+		scope,
+		project_id,
+		status,
+		confidence,
+		source_session,
+		created_at,
+		last_updated
+	)
+	SELECT
+		p.id,
+		p.key,
+		p.value,
+		'global',
+		NULL,
+		'confirmed',
+		p.confidence,
+		p.source_session,
+		p.created_at,
+		p.last_updated
+	FROM preferences p
+	WHERE NOT EXISTS (
+		SELECT 1
+		FROM preference_records pr
+		WHERE pr.id = p.id
+	)`);
+
 	database.run(`CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
 		content, summary,
 		content=observations,
@@ -79,9 +141,9 @@ export function getMemoryDb(dbPath?: string): Database {
 	const resolvedPath =
 		dbPath ??
 		(() => {
-			const memoryDir = join(getGlobalConfigDir(), MEMORY_DIR);
-			mkdirSync(memoryDir, { recursive: true });
-			return join(memoryDir, DB_FILE);
+			const runtimeDbPath = getAutopilotDbPath();
+			mkdirSync(dirname(runtimeDbPath), { recursive: true });
+			return runtimeDbPath;
 		})();
 
 	db = new Database(resolvedPath);

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/index.ts

@@ -1,4 +1,9 @@
-export { createMemoryCaptureHandler, type MemoryCaptureDeps } from "./capture";
+export {
+	createMemoryCaptureHandler,
+	createMemoryChatMessageHandler,
+	type MemoryCaptureDeps,
+	memoryCaptureInternals,
+} from "./capture";
 export * from "./constants";
 export { closeMemoryDb, getMemoryDb, initMemoryDb } from "./database";
 export { computeRelevanceScore, pruneStaleObservations } from "./decay";
@@ -6,13 +11,24 @@ export { createMemoryInjector, type MemoryInjectorConfig } from "./injector";
 export { computeProjectKey } from "./project-key";
 export {
 	deleteObservation,
+	deletePreferenceRecord,
+	deletePreferencesByKey,
 	getAllPreferences,
+	getConfirmedPreferencesForProject,
 	getObservationsByProject,
+	getPreferenceRecordById,
 	getProjectByPath,
+	getRecentFailureObservations,
 	insertObservation,
+	listPreferenceEvidence,
+	listPreferenceRecords,
+	listRelevantLessons,
+	prunePreferenceEvidence,
+	prunePreferences,
 	searchObservations,
 	updateAccessCount,
 	upsertPreference,
+	upsertPreferenceRecord,
 	upsertProject,
 } from "./repository";
 export {

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,
+	]);
+}