@kodrunhq/opencode-autopilot 1.5.0 → 1.6.0

package/src/memory/index.ts

@@ -0,0 +1,24 @@
+export { createMemoryCaptureHandler, type MemoryCaptureDeps } from "./capture";
+export * from "./constants";
+export { closeMemoryDb, getMemoryDb, initMemoryDb } from "./database";
+export { computeRelevanceScore, pruneStaleObservations } from "./decay";
+export { createMemoryInjector, type MemoryInjectorConfig } from "./injector";
+export { computeProjectKey } from "./project-key";
+export {
+	deleteObservation,
+	getAllPreferences,
+	getObservationsByProject,
+	getProjectByPath,
+	insertObservation,
+	searchObservations,
+	updateAccessCount,
+	upsertPreference,
+	upsertProject,
+} from "./repository";
+export {
+	buildMemoryContext,
+	retrieveMemoryContext,
+	type ScoredObservation,
+	scoreAndRankObservations,
+} from "./retrieval";
+export * from "./types";

package/src/memory/injector.ts

@@ -0,0 +1,85 @@
+/**
+ * System prompt injection for memory context.
+ *
+ * Creates a per-session cached injector that retrieves relevant memories
+ * and pushes them into the system prompt via output.system.
+ *
+ * Best-effort: all errors are silently caught to never break the session.
+ * Same pattern as skill-injection.ts.
+ *
+ * @module
+ */
+
+import type { Database } from "bun:sqlite";
+import { retrieveMemoryContext } from "./retrieval";
+
+/**
+ * Configuration for creating a memory injector.
+ */
+export interface MemoryInjectorConfig {
+	readonly projectRoot: string;
+	readonly tokenBudget: number;
+	readonly halfLifeDays: number;
+	readonly getDb: () => Database;
+}
+
+/**
+ * Input shape matching the experimental.chat.system.transform hook signature.
+ */
+interface InjectorInput {
+	readonly sessionID?: string;
+	readonly model: Record<string, unknown>;
+}
+
+/**
+ * Output shape matching the experimental.chat.system.transform hook signature.
+ * system is mutable — the hook API expects callers to push into it.
+ */
+interface InjectorOutput {
+	system: string[];
+}
+
+/**
+ * Create a memory injector function for the experimental.chat.system.transform hook.
+ *
+ * Returns an async function that:
+ * 1. Skips if no sessionID is provided
+ * 2. Returns cached context for known sessions
+ * 3. Retrieves and caches memory context for new sessions
+ * 4. Pushes non-empty context to output.system
+ *
+ * All errors are silently caught (best-effort, per D-24 and skill-injection pattern).
+ */
+export function createMemoryInjector(config: MemoryInjectorConfig) {
+	const cache = new Map<string, string>();
+
+	return async (input: InjectorInput, output: InjectorOutput): Promise<void> => {
+		try {
+			if (!input.sessionID) return;
+
+			const cached = cache.get(input.sessionID);
+			if (cached !== undefined) {
+				if (cached.length > 0) {
+					output.system.push(cached);
+				}
+				return;
+			}
+
+			const db = config.getDb();
+			const context = retrieveMemoryContext(
+				config.projectRoot,
+				config.tokenBudget,
+				db,
+				config.halfLifeDays,
+			);
+
+			cache.set(input.sessionID, context);
+
+			if (context.length > 0) {
+				output.system.push(context);
+			}
+		} catch (err) {
+			console.warn("[opencode-autopilot] memory injection failed:", err);
+		}
+	};
+}

package/src/memory/project-key.ts

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+
+export function computeProjectKey(projectPath: string): string {
+	return createHash("sha256").update(projectPath).digest("hex");
+}

package/src/memory/repository.ts

@@ -0,0 +1,217 @@
+import type { Database } from "bun:sqlite";
+import { OBSERVATION_TYPES } from "./constants";
+import { getMemoryDb } from "./database";
+import { observationSchema, preferenceSchema, projectSchema } from "./schemas";
+import type { Observation, ObservationType, Preference, Project } 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"; // safe fallback for corrupt/unknown types
+}
+
+/** 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,
+	};
+}
+
+/** Map a snake_case DB row to camelCase Project. */
+function rowToProject(row: Record<string, unknown>): Project {
+	return {
+		id: row.id as string,
+		path: row.path as string,
+		name: row.name as string,
+		lastUpdated: row.last_updated as string,
+	};
+}
+
+/** Map a snake_case DB row to camelCase Preference. */
+function rowToPreference(row: Record<string, unknown>): Preference {
+	return {
+		id: row.id as string,
+		key: row.key as string,
+		value: row.value as string,
+		confidence: row.confidence as number,
+		sourceSession: (row.source_session as string) ?? null,
+		createdAt: row.created_at as string,
+		lastUpdated: row.last_updated 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);
+
+	d.run(
+		`INSERT INTO observations (project_id, session_id, type, content, summary, confidence, access_count, created_at, last_accessed)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		[
+			validated.projectId,
+			validated.sessionId,
+			validated.type,
+			validated.content,
+			validated.summary,
+			validated.confidence,
+			validated.accessCount,
+			validated.createdAt,
+			validated.lastAccessed,
+		],
+	);
+
+	const row = d.query("SELECT last_insert_rowid() as id").get() as { id: number };
+	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 = ?";
+
+	// Sanitize FTS5 query — wrap in double-quotes to prevent operator injection
+	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,
+	}));
+}
+
+/**
+ * Create or replace a project record.
+ */
+export function upsertProject(project: Project, db?: Database): void {
+	const validated = projectSchema.parse(project);
+	const d = resolveDb(db);
+	d.run(`INSERT OR REPLACE INTO projects (id, path, name, last_updated) VALUES (?, ?, ?, ?)`, [
+		validated.id,
+		validated.path,
+		validated.name,
+		validated.lastUpdated,
+	]);
+}
+
+/**
+ * Get a project by its filesystem path. Returns null if not found.
+ */
+export function getProjectByPath(path: string, db?: Database): Project | null {
+	const d = resolveDb(db);
+	const row = d.query("SELECT * FROM projects WHERE path = ?").get(path) as Record<
+		string,
+		unknown
+	> | null;
+	return row ? rowToProject(row) : null;
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Create or replace a preference by its id.
+ */
+export function upsertPreference(pref: Preference, db?: Database): void {
+	const validated = preferenceSchema.parse(pref);
+	const d = resolveDb(db);
+	d.run(
+		`INSERT OR REPLACE INTO preferences (id, key, value, confidence, source_session, created_at, last_updated)
+		 VALUES (?, ?, ?, ?, ?, ?, ?)`,
+		[
+			validated.id,
+			validated.key,
+			validated.value,
+			validated.confidence,
+			validated.sourceSession,
+			validated.createdAt,
+			validated.lastUpdated,
+		],
+	);
+}
+
+/**
+ * Get all preferences.
+ */
+export function getAllPreferences(db?: Database): readonly Preference[] {
+	const d = resolveDb(db);
+	const rows = d.query("SELECT * FROM preferences").all() as Array<Record<string, unknown>>;
+	return rows.map(rowToPreference);
+}
+
+/**
+ * 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,
+	]);
+}

package/src/memory/retrieval.ts

@@ -0,0 +1,260 @@
+/**
+ * 3-layer progressive disclosure retrieval with token-budgeted context building.
+ *
+ * Layer 1 (always): Observation summaries grouped by type (up to 5 per group)
+ * Layer 2 (if budget allows): Recent Activity timeline
+ * Layer 3 (if budget allows): Full content for top 1-2 observations
+ *
+ * Token budget enforcement: never exceeds CHARS_PER_TOKEN * tokenBudget characters.
+ * Same approach as buildMultiSkillContext in src/skills/adaptive-injector.ts.
+ *
+ * @module
+ */
+
+import type { Database } from "bun:sqlite";
+import { CHARS_PER_TOKEN, DEFAULT_INJECTION_BUDGET } from "./constants";
+import { computeRelevanceScore } from "./decay";
+import { getAllPreferences, getObservationsByProject, getProjectByPath } from "./repository";
+import type { Observation, Preference } from "./types";
+
+/**
+ * An observation with its computed relevance score.
+ */
+export type ScoredObservation = Observation & { readonly relevanceScore: number };
+
+/**
+ * Score and rank observations by relevance (descending).
+ */
+export function scoreAndRankObservations(
+	observations: readonly Observation[],
+	halfLifeDays?: number,
+): readonly ScoredObservation[] {
+	return observations
+		.map((obs) => ({
+			...obs,
+			relevanceScore: computeRelevanceScore(
+				obs.lastAccessed,
+				obs.accessCount,
+				obs.type,
+				halfLifeDays,
+			),
+		}))
+		.sort((a, b) => b.relevanceScore - a.relevanceScore);
+}
+
+/**
+ * Type-to-section header mapping for Layer 1 grouping.
+ */
+const SECTION_HEADERS: Readonly<Record<string, string>> = Object.freeze({
+	decision: "### Key Decisions",
+	pattern: "### Patterns",
+	error: "### Recent Errors",
+	preference: "### Learned Preferences",
+	context: "### Context Notes",
+	tool_usage: "### Tool Usage Patterns",
+});
+
+/** Section display order (most valuable first). */
+const SECTION_ORDER = ["decision", "pattern", "error", "preference", "context", "tool_usage"];
+
+/** Max observations per group in Layer 1. */
+const MAX_PER_GROUP = 5;
+
+/** Minimum chars remaining to include Layer 2. */
+const LAYER_2_THRESHOLD = 500;
+
+/** Minimum chars remaining to include Layer 3. */
+const LAYER_3_THRESHOLD = 1000;
+
+/**
+ * Options for building memory context.
+ */
+interface BuildMemoryContextOptions {
+	readonly projectName: string;
+	readonly lastSessionDate: string | null;
+	readonly observations: readonly ScoredObservation[];
+	readonly preferences: readonly Preference[];
+	readonly tokenBudget?: number;
+}
+
+/**
+ * Build a markdown memory context string within token budget.
+ *
+ * Uses 3-layer progressive disclosure:
+ * - Layer 1: Summaries grouped by type (always included if budget allows)
+ * - Layer 2: Recent Activity timeline (if remaining budget > 500 chars)
+ * - Layer 3: Full content for top observations (if remaining budget > 1000 chars)
+ */
+export function buildMemoryContext(options: BuildMemoryContextOptions): string {
+	const {
+		projectName,
+		lastSessionDate,
+		observations,
+		preferences,
+		tokenBudget = DEFAULT_INJECTION_BUDGET,
+	} = options;
+
+	if (observations.length === 0 && preferences.length === 0) return "";
+
+	const charBudget = tokenBudget * CHARS_PER_TOKEN;
+	let totalChars = 0;
+	const parts: string[] = [];
+
+	// Header
+	const header = `## Project Memory (auto-injected)\n**Project:** ${projectName}\n**Last session:** ${lastSessionDate ?? "first session"}\n`;
+	if (totalChars + header.length > charBudget) {
+		return header.slice(0, charBudget);
+	}
+	parts.push(header);
+	totalChars += header.length;
+
+	// --- Layer 1: Grouped summaries ---
+	// Sort by relevance within the function to ensure highest-first in each group
+	const sorted = [...observations].sort((a, b) => b.relevanceScore - a.relevanceScore);
+	const grouped = groupByType(sorted);
+
+	for (const type of SECTION_ORDER) {
+		const group = grouped.get(type);
+		if (!group || group.length === 0) continue;
+
+		const sectionHeader = SECTION_HEADERS[type] ?? `### ${type}`;
+		const items = group.slice(0, MAX_PER_GROUP);
+		const lines = items.map((obs) => `- ${obs.summary} (confidence: ${obs.confidence})`);
+		const section = `\n${sectionHeader}\n${lines.join("\n")}\n`;
+
+		if (totalChars + section.length > charBudget) break;
+		parts.push(section);
+		totalChars += section.length;
+	}
+
+	// Preferences section
+	if (preferences.length > 0) {
+		const prefLines = preferences.map((p) => `- **${p.key}:** ${p.value}`);
+		const prefSection = `\n### Preferences\n${prefLines.join("\n")}\n`;
+
+		if (totalChars + prefSection.length <= charBudget) {
+			parts.push(prefSection);
+			totalChars += prefSection.length;
+		}
+	}
+
+	// --- Layer 2: Recent Activity timeline (if budget allows) ---
+	const remainingAfterL1 = charBudget - totalChars;
+	if (remainingAfterL1 > LAYER_2_THRESHOLD && observations.length > 0) {
+		const timeline = buildTimeline(observations);
+		if (timeline.length > 0) {
+			const timelineSection = `\n### Recent Activity\n${timeline}\n`;
+			if (totalChars + timelineSection.length <= charBudget) {
+				parts.push(timelineSection);
+				totalChars += timelineSection.length;
+			}
+		}
+	}
+
+	// --- Layer 3: Full content for top observations (if budget allows) ---
+	const remainingAfterL2 = charBudget - totalChars;
+	if (remainingAfterL2 > LAYER_3_THRESHOLD && observations.length > 0) {
+		const topObs = observations.slice(0, 2);
+		const detailLines: string[] = [];
+		const headerOverhead = "\n### Details\n\n".length;
+		let linesBudget = remainingAfterL2 - headerOverhead;
+
+		for (const obs of topObs) {
+			const detail = `**${obs.type}:** ${obs.content}`;
+			const cost = detail.length + 1;
+			if (cost > linesBudget) break;
+			detailLines.push(detail);
+			linesBudget -= cost;
+		}
+
+		if (detailLines.length > 0) {
+			const detailSection = `\n### Details\n${detailLines.join("\n")}\n`;
+			if (totalChars + detailSection.length <= charBudget) {
+				parts.push(detailSection);
+				totalChars += detailSection.length;
+			}
+		}
+	}
+
+	const result = parts.join("");
+	// Final safety truncation
+	return result.length > charBudget ? result.slice(0, charBudget) : result;
+}
+
+/**
+ * Group scored observations by type, preserving relevance order within groups.
+ */
+function groupByType(
+	observations: readonly ScoredObservation[],
+): ReadonlyMap<string, readonly ScoredObservation[]> {
+	const groups = new Map<string, ScoredObservation[]>();
+
+	for (const obs of observations) {
+		const existing = groups.get(obs.type);
+		if (existing) {
+			existing.push(obs);
+		} else {
+			groups.set(obs.type, [obs]);
+		}
+	}
+
+	return groups;
+}
+
+/**
+ * Build a brief timeline of recent sessions from observations.
+ */
+function buildTimeline(observations: readonly ScoredObservation[]): string {
+	// Group by session, take last 5 sessions
+	const sessions = new Map<string, { date: string; count: number }>();
+
+	for (const obs of observations) {
+		const existing = sessions.get(obs.sessionId);
+		if (existing) {
+			existing.count++;
+			if (new Date(obs.createdAt).getTime() > new Date(existing.date).getTime()) {
+				existing.date = obs.createdAt;
+			}
+		} else {
+			sessions.set(obs.sessionId, { date: obs.createdAt, count: 1 });
+		}
+	}
+
+	const sorted = [...sessions.values()]
+		.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+		.slice(0, 5);
+
+	return sorted
+		.map((s) => {
+			const dateStr = s.date.split("T")[0];
+			return `- ${dateStr}: ${s.count} observation${s.count !== 1 ? "s" : ""}`;
+		})
+		.join("\n");
+}
+
+/**
+ * Convenience function: retrieve memory context for a project path.
+ *
+ * Ties together: project lookup, observation retrieval, scoring, preferences, and context building.
+ */
+export function retrieveMemoryContext(
+	projectPath: string,
+	tokenBudget?: number,
+	db?: Database,
+	halfLifeDays?: number,
+): string {
+	const project = getProjectByPath(projectPath, db);
+	if (!project) return "";
+
+	const observations = getObservationsByProject(project.id, 100, db);
+	const scored = scoreAndRankObservations(observations, halfLifeDays);
+	const preferences = getAllPreferences(db);
+
+	return buildMemoryContext({
+		projectName: project.name,
+		lastSessionDate: project.lastUpdated,
+		observations: scored,
+		preferences,
+		tokenBudget,
+	});
+}

package/src/memory/schemas.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { OBSERVATION_TYPES } from "./constants";
+
+export const observationTypeSchema = z.enum(OBSERVATION_TYPES);
+
+export const observationSchema = z.object({
+	id: z.number().int().optional(),
+	projectId: z.string().nullable(),
+	sessionId: z.string(),
+	type: observationTypeSchema,
+	content: z.string().min(1).max(10000),
+	summary: z.string().min(1).max(500),
+	confidence: z.number().min(0).max(1).default(0.5),
+	accessCount: z.number().int().min(0).default(0),
+	createdAt: z.string(),
+	lastAccessed: z.string(),
+});
+
+export const projectSchema = z.object({
+	id: z.string(),
+	path: z.string(),
+	name: z.string(),
+	lastUpdated: z.string(),
+});
+
+export const preferenceSchema = z.object({
+	id: z.string(),
+	key: z.string().min(1).max(200),
+	value: z.string().min(1).max(2000),
+	confidence: z.number().min(0).max(1).default(0.5),
+	sourceSession: z.string().nullable().default(null),
+	createdAt: z.string(),
+	lastUpdated: z.string(),
+});

package/src/memory/types.ts

@@ -0,0 +1,12 @@
+import type { z } from "zod";
+import type {
+	observationSchema,
+	observationTypeSchema,
+	preferenceSchema,
+	projectSchema,
+} from "./schemas";
+
+export type ObservationType = z.infer<typeof observationTypeSchema>;
+export type Observation = z.infer<typeof observationSchema>;
+export type Project = z.infer<typeof projectSchema>;
+export type Preference = z.infer<typeof preferenceSchema>;

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 4 as const,
+		version: 5 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},