@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/logging/rotation.ts

@@ -0,0 +1,261 @@
+/**
+ * Log rotation and retention for the OpenCode Autopilot plugin.
+ *
+ * Handles:
+ * - Max file-count enforcement (oldest files pruned first)
+ * - Time-based expiry (files older than `maxAgeDays` are removed)
+ * - Gzip compression of rotated `.log` / `.jsonl` files
+ *
+ * All filesystem operations use `node:fs/promises` for portability.
+ *
+ * @module
+ */
+
+import { createReadStream, createWriteStream } from "node:fs";
+import { readdir, rename, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { createGzip } from "node:zlib";
+import { isEnoentError } from "../utils/fs-helpers";
+
+/** Extensions eligible for gzip compression during rotation. */
+const COMPRESSIBLE_EXTENSIONS = new Set([".log", ".jsonl"]);
+
+/** Default maximum number of log files to keep (excluding compressed archives). */
+const DEFAULT_MAX_FILES = 10;
+
+/** Default maximum log file size in bytes (10 MiB). */
+const DEFAULT_MAX_SIZE_BYTES = 10 * 1024 * 1024;
+
+/** Default maximum age in days before a file is deleted. */
+const DEFAULT_MAX_AGE_DAYS = 30;
+
+export interface RotationOptions {
+	/**
+	 * Maximum number of log files to retain (oldest are pruned first).
+	 * Does not count `.gz` archives.
+	 * @default 10
+	 */
+	readonly maxFiles?: number;
+
+	/**
+	 * Maximum individual file size in bytes. Files exceeding this limit are
+	 * compressed and renamed with a `.gz` extension before the next write.
+	 * @default 10_485_760 (10 MiB)
+	 */
+	readonly maxSize?: number;
+
+	/**
+	 * Maximum age in days. Files (and archives) older than this are deleted.
+	 * @default 30
+	 */
+	readonly maxAgeDays?: number;
+}
+
+export interface RotationResult {
+	/** Number of files compressed into `.gz` archives. */
+	readonly compressed: number;
+	/** Number of files deleted (age or count limit exceeded). */
+	readonly deleted: number;
+}
+
+interface FileEntry {
+	readonly name: string;
+	readonly path: string;
+	readonly mtimeMs: number;
+	readonly size: number;
+}
+
+function isCompressible(name: string): boolean {
+	const dot = name.lastIndexOf(".");
+	if (dot === -1) return false;
+	const ext = name.slice(dot);
+	return COMPRESSIBLE_EXTENSIONS.has(ext);
+}
+
+function isArchive(name: string): boolean {
+	return name.endsWith(".gz");
+}
+
+/**
+ * Compresses `sourcePath` to `sourcePath + ".gz"` then removes the original.
+ * Returns `true` on success, `false` if the source vanished mid-flight.
+ */
+async function gzipFile(sourcePath: string): Promise<boolean> {
+	const archivePath = `${sourcePath}.gz`;
+	await new Promise<void>((resolve, reject) => {
+		const readStream = createReadStream(sourcePath);
+		const writeStream = createWriteStream(archivePath);
+		const gzip = createGzip();
+
+		readStream.on("error", reject);
+		writeStream.on("error", reject);
+		writeStream.on("finish", resolve);
+
+		readStream.pipe(gzip).pipe(writeStream);
+	});
+	// Only remove the original after the archive is fully written.
+	await unlink(sourcePath);
+	return true;
+}
+
+/**
+ * Reads all entries in `logDir`, resolving `stat` for each.
+ * Silently skips entries that disappear between readdir and stat.
+ */
+async function listEntries(logDir: string): Promise<readonly FileEntry[]> {
+	let names: string[];
+	try {
+		names = await readdir(logDir);
+	} catch (error: unknown) {
+		if (isEnoentError(error)) return [];
+		throw error;
+	}
+
+	const entries: FileEntry[] = [];
+	for (const name of names) {
+		const filePath = join(logDir, name);
+		try {
+			const fileStat = await stat(filePath);
+			if (!fileStat.isFile()) continue;
+			entries.push({
+				name,
+				path: filePath,
+				mtimeMs: fileStat.mtimeMs,
+				size: fileStat.size,
+			});
+		} catch (error: unknown) {
+			if (!isEnoentError(error)) throw error;
+			// File disappeared between readdir and stat — skip it.
+		}
+	}
+
+	return entries;
+}
+
+/**
+ * Checks whether a single file exceeds the given `maxSize` threshold.
+ *
+ * Intended for use by writers that want to rotate before the next append.
+ *
+ * @param filePath - Absolute path to the log file.
+ * @param maxSize  - Size limit in bytes.
+ * @returns `true` when the file exists and its size exceeds `maxSize`.
+ */
+export async function exceedsMaxSize(filePath: string, maxSize: number): Promise<boolean> {
+	try {
+		const fileStat = await stat(filePath);
+		return fileStat.isFile() && fileStat.size > maxSize;
+	} catch (error: unknown) {
+		if (isEnoentError(error)) return false;
+		throw error;
+	}
+}
+
+/**
+ * Rotates a single active log file by compressing it to `<filePath>.gz`.
+ *
+ * The caller is responsible for opening a fresh log file afterwards.
+ * Returns `true` when the file was successfully rotated, `false` when the
+ * file did not exist (nothing to rotate).
+ *
+ * @param filePath - Absolute path to the log file to rotate.
+ */
+export async function rotateFile(filePath: string): Promise<boolean> {
+	try {
+		const fileStat = await stat(filePath);
+		if (!fileStat.isFile()) return false;
+	} catch (error: unknown) {
+		if (isEnoentError(error)) return false;
+		throw error;
+	}
+
+	if (!isCompressible(filePath)) {
+		// Non-compressible files are renamed with a timestamp suffix.
+		const rotatedPath = `${filePath}.${Date.now()}.bak`;
+		await rename(filePath, rotatedPath);
+		return true;
+	}
+
+	return gzipFile(filePath);
+}
+
+/**
+ * Runs the full rotation and retention policy for all log files in `logDir`.
+ *
+ * **What this does (in order):**
+ * 1. Compress oversized `.log` / `.jsonl` files into `.gz` archives.
+ * 2. Delete files (any extension) older than `maxAgeDays`.
+ * 3. Prune oldest plain log files when their count exceeds `maxFiles`.
+ *
+ * @param logDir  - Directory containing log files.
+ * @param options - Rotation and retention options.
+ * @returns Counts of compressed and deleted files.
+ */
+export async function rotateLogs(
+	logDir: string,
+	options?: RotationOptions,
+): Promise<RotationResult> {
+	const maxFiles = options?.maxFiles ?? DEFAULT_MAX_FILES;
+	const maxSize = options?.maxSize ?? DEFAULT_MAX_SIZE_BYTES;
+	const maxAgeDays = options?.maxAgeDays ?? DEFAULT_MAX_AGE_DAYS;
+	const ageThresholdMs = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+
+	let compressed = 0;
+	let deleted = 0;
+
+	// --- Pass 1: Compress oversized plain log files ---
+	{
+		const entries = await listEntries(logDir);
+		for (const entry of entries) {
+			if (isArchive(entry.name)) continue;
+			if (!isCompressible(entry.name)) continue;
+			if (entry.size <= maxSize) continue;
+
+			try {
+				const rotated = await gzipFile(entry.path);
+				if (rotated) compressed++;
+			} catch (error: unknown) {
+				if (!isEnoentError(error)) throw error;
+				// File disappeared — not an error.
+			}
+		}
+	}
+
+	// --- Pass 2: Delete files older than maxAgeDays (any extension) ---
+	{
+		const entries = await listEntries(logDir);
+		for (const entry of entries) {
+			if (entry.mtimeMs >= ageThresholdMs) continue;
+
+			try {
+				await unlink(entry.path);
+				deleted++;
+			} catch (error: unknown) {
+				if (!isEnoentError(error)) throw error;
+			}
+		}
+	}
+
+	// --- Pass 3: Prune oldest plain log files that exceed maxFiles count ---
+	{
+		const entries = await listEntries(logDir);
+		const plainLogs = entries
+			.filter((e) => !isArchive(e.name) && isCompressible(e.name))
+			.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
+
+		const overflow = plainLogs.length - maxFiles;
+		if (overflow > 0) {
+			const toDelete = plainLogs.slice(0, overflow);
+			for (const entry of toDelete) {
+				try {
+					await unlink(entry.path);
+					deleted++;
+				} catch (error: unknown) {
+					if (!isEnoentError(error)) throw error;
+				}
+			}
+		}
+	}
+
+	return { compressed, deleted };
+}

package/src/logging/types.ts

@@ -0,0 +1,33 @@
+/**
+ * Logging type definitions for the OpenCode Autopilot plugin.
+ *
+ * @module
+ */
+
+export type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+
+export interface LogMetadata {
+	readonly domain: string;
+	readonly subsystem?: string;
+	readonly operation?: string;
+	readonly [key: string]: unknown;
+}
+
+export interface LogEntry {
+	readonly timestamp: string;
+	readonly level: LogLevel;
+	readonly message: string;
+	readonly metadata: LogMetadata;
+}
+
+export interface LogSink {
+	write(entry: LogEntry): void;
+}
+
+export interface Logger {
+	debug(message: string, metadata?: Partial<LogMetadata>): void;
+	info(message: string, metadata?: Partial<LogMetadata>): void;
+	warn(message: string, metadata?: Partial<LogMetadata>): void;
+	error(message: string, metadata?: Partial<LogMetadata>): void;
+	child(metadata: Partial<LogMetadata>): Logger;
+}

package/src/memory/capture-utils.ts

@@ -0,0 +1,149 @@
+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;
+
+export interface PreferenceCandidate {
+	readonly key: string;
+	readonly value: string;
+	readonly scope: "global" | "project";
+	readonly confidence: number;
+	readonly statement: string;
+}
+
+export 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;
+}
+
+export 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";
+}
+
+export function normalizePreferenceValue(value: string): string {
+	return value
+		.replace(/\s+/g, " ")
+		.trim()
+		.replace(/[.!?]+$/, "");
+}
+
+export function inferPreferenceScope(text: string): "global" | "project" {
+	const lowerText = text.toLowerCase();
+	return PROJECT_SCOPE_HINTS.some((hint) => lowerText.includes(hint)) ? "project" : "global";
+}
+
+export 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;
+}
+
+export 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;
+		}),
+	);
+}
+
+export function truncate(s: string, maxLen: number): string {
+	return s.length > maxLen ? s.slice(0, maxLen) : s;
+}

package/src/memory/capture.ts

@@ -1,35 +1,19 @@
-/**
- * Event capture handler for memory observations.
- *
- * Subscribes to OpenCode session events and extracts memory-worthy
- * observations from decision, error, and phase_transition events.
- * Noisy events (tool_complete, context_warning, session_start/end)
- * are filtered out per Research Pitfall 4.
- *
- * Factory pattern matches createObservabilityEventHandler in
- * src/observability/event-handlers.ts.
- *
- * @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 { computeProjectKey } from "./project-key";
-import { insertObservation, upsertProject } from "./repository";
+import { insertObservation, upsertPreferenceRecord, upsertProject } from "./repository";
 import type { ObservationType } from "./types";
 
-/**
- * Dependencies for the memory capture handler.
- */
+const logger = getLogger("memory", "capture");
+
 export interface MemoryCaptureDeps {
 	readonly getDb: () => Database;
 	readonly projectRoot: string;
 }
 
-/**
- * Events that produce memory observations.
- */
 const CAPTURE_EVENT_TYPES = new Set([
 	"session.created",
 	"session.deleted",
@@ -38,35 +22,6 @@ const CAPTURE_EVENT_TYPES = new Set([
 	"app.phase_transition",
 ]);
 
-/**
- * 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;
-}
-
-/**
- * Safely truncate a string to maxLen characters.
- */
-function truncate(s: string, maxLen: number): string {
-	return s.length > maxLen ? s.slice(0, maxLen) : s;
-}
-
-/**
- * Creates a memory capture handler that subscribes to OpenCode events.
- *
- * Returns an async function matching the event handler signature:
- * `(input: { event: { type: string; [key: string]: unknown } }) => Promise<void>`
- *
- * Pure observer: never modifies the event or session output.
- */
 export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 	let currentSessionId: string | null = null;
 	let currentProjectKey: string | null = null;
@@ -87,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(),
@@ -96,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) });
 		}
 	}
 
@@ -110,7 +65,6 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				? (rawProps as Record<string, unknown>)
 				: {};
 
-		// Skip noisy events early
 		if (!CAPTURE_EVENT_TYPES.has(event.type)) return;
 
 		switch (event.type) {
@@ -121,7 +75,10 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				if (!info.id) return;
 
 				currentSessionId = info.id;
-				currentProjectKey = computeProjectKey(deps.projectRoot);
+				const resolvedProject = await resolveProjectIdentity(deps.projectRoot, {
+					db: deps.getDb(),
+				});
+				currentProjectKey = resolvedProject.id;
 				const projectName = basename(deps.projectRoot);
 
 				try {
@@ -130,12 +87,13 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 							id: currentProjectKey,
 							path: deps.projectRoot,
 							name: projectName,
+							firstSeenAt: resolvedProject.firstSeenAt,
 							lastUpdated: now(),
 						},
 						deps.getDb(),
 					);
 				} catch (err) {
-					console.warn("[opencode-autopilot] upsertProject failed:", err);
+					logger.warn("upsertProject failed", { error: String(err) });
 				}
 				return;
 			}
@@ -144,18 +102,15 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				const projectKey = currentProjectKey;
 				const db = deps.getDb();
 
-				// Reset state
 				currentSessionId = null;
 				currentProjectKey = null;
 
-				// Defer pruning to avoid blocking the session.deleted handler.
-				// Best-effort: will not run if the process exits before this microtask drains.
 				if (projectKey) {
 					queueMicrotask(() => {
 						try {
 							pruneStaleObservations(projectKey, db);
 						} catch (err) {
-							console.warn("[opencode-autopilot] pruneStaleObservations failed:", err);
+							logger.warn("pruneStaleObservations failed", { error: String(err) });
 						}
 					});
 				}
@@ -163,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 : "";
@@ -185,21 +140,20 @@ 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 =
 					typeof properties.fromPhase === "string" ? properties.fromPhase : "unknown";
 				const toPhase = typeof properties.toPhase === "string" ? properties.toPhase : "unknown";
 				const content = `Phase transition: ${fromPhase} -> ${toPhase}`;
-				const summary = content;
 
-				safeInsert("pattern", content, summary, 0.6);
+				safeInsert("pattern", content, content, 0.6);
 				return;
 			}
 
@@ -208,3 +162,64 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 		}
 	};
 }
+
+export function createMemoryChatMessageHandler(deps: MemoryCaptureDeps) {
+	return async (
+		input: { readonly sessionID: string },
+		output: { readonly parts: unknown[] },
+	): Promise<void> => {
+		try {
+			const candidates = captureUtils.extractExplicitPreferenceCandidates(output.parts);
+			if (candidates.length === 0) {
+				return;
+			}
+
+			const resolvedProject = await resolveProjectIdentity(deps.projectRoot, {
+				db: deps.getDb(),
+			});
+			const projectName = basename(deps.projectRoot);
+			const timestamp = new Date().toISOString();
+
+			upsertProject(
+				{
+					id: resolvedProject.id,
+					path: deps.projectRoot,
+					name: projectName,
+					firstSeenAt: resolvedProject.firstSeenAt,
+					lastUpdated: timestamp,
+				},
+				deps.getDb(),
+			);
+
+			for (const candidate of candidates) {
+				upsertPreferenceRecord(
+					{
+						key: candidate.key,
+						value: candidate.value,
+						scope: candidate.scope,
+						projectId: candidate.scope === "project" ? resolvedProject.id : null,
+						status: "confirmed",
+						confidence: candidate.confidence,
+						sourceSession: input.sessionID,
+						createdAt: timestamp,
+						lastUpdated: timestamp,
+						evidence: [
+							{
+								sessionId: input.sessionID,
+								statement: candidate.statement,
+								confidence: candidate.confidence,
+								confirmed: true,
+								createdAt: timestamp,
+							},
+						],
+					},
+					deps.getDb(),
+				);
+			}
+		} catch (err) {
+			logger.warn("explicit preference capture failed", { error: String(err) });
+		}
+	};
+}
+
+export { captureUtils as memoryCaptureInternals };