@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/background/repository.ts

@@ -0,0 +1,174 @@
+import type { Database } from "bun:sqlite";
+import { withTransaction } from "../kernel/transaction";
+import type { TaskStatus } from "../types/background";
+import {
+	type BackgroundTaskRecord,
+	type BackgroundTaskResultRecord,
+	type CreateBackgroundTaskInput,
+	createTaskId,
+	createTimestamp,
+	getTaskByIdRow,
+	listBackgroundTasks,
+} from "./database";
+import { assertTransition } from "./state-machine";
+
+export interface TaskUpdatePayload {
+	readonly result?: string | null;
+	readonly error?: string | null;
+	readonly now?: string;
+}
+
+export function createTask(db: Database, task: CreateBackgroundTaskInput): BackgroundTaskRecord {
+	return withTransaction(db, () => {
+		const timestamp = task.createdAt ?? createTimestamp();
+		const nextTask = Object.freeze({
+			id: task.id ?? createTaskId(),
+			sessionId: task.sessionId,
+			description: task.description,
+			category: task.category ?? null,
+			status: task.status ?? "pending",
+			result: task.result ?? null,
+			error: task.error ?? null,
+			agent: task.agent ?? null,
+			model: task.model ?? null,
+			priority: task.priority ?? 50,
+			createdAt: timestamp,
+			updatedAt: task.updatedAt ?? timestamp,
+			startedAt: task.startedAt ?? null,
+			completedAt: task.completedAt ?? null,
+		});
+
+		db.run(
+			`INSERT INTO background_tasks (
+				id, session_id, description, category, status, result, error, agent, model, priority,
+				created_at, updated_at, started_at, completed_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				nextTask.id,
+				nextTask.sessionId,
+				nextTask.description,
+				nextTask.category,
+				nextTask.status,
+				nextTask.result,
+				nextTask.error,
+				nextTask.agent,
+				nextTask.model,
+				nextTask.priority,
+				nextTask.createdAt,
+				nextTask.updatedAt,
+				nextTask.startedAt,
+				nextTask.completedAt,
+			],
+		);
+
+		const createdTask = getTaskByIdRow(db, nextTask.id);
+		if (!createdTask) {
+			throw new Error(`Failed to create background task '${nextTask.id}'`);
+		}
+
+		return createdTask;
+	});
+}
+
+export function updateStatus(
+	db: Database,
+	taskId: string,
+	newStatus: TaskStatus,
+	payload: TaskUpdatePayload = {},
+): BackgroundTaskRecord {
+	return withTransaction(db, () => {
+		const currentTask = getTaskByIdRow(db, taskId);
+		if (!currentTask) {
+			throw new Error(`Background task '${taskId}' not found`);
+		}
+
+		assertTransition(currentTask.status, newStatus);
+
+		const timestamp = payload.now ?? createTimestamp();
+		const startedAt =
+			newStatus === "running" ? (currentTask.startedAt ?? timestamp) : currentTask.startedAt;
+		const completedAt =
+			newStatus === "completed" || newStatus === "failed" || newStatus === "cancelled"
+				? timestamp
+				: currentTask.completedAt;
+		const result =
+			newStatus === "completed" ? (payload.result ?? currentTask.result) : currentTask.result;
+		const error = newStatus === "failed" ? (payload.error ?? currentTask.error) : null;
+
+		db.run(
+			`UPDATE background_tasks
+			 SET status = ?, result = ?, error = ?, updated_at = ?, started_at = ?, completed_at = ?
+			 WHERE id = ?`,
+			[newStatus, result, error, timestamp, startedAt, completedAt, taskId],
+		);
+
+		const updatedTask = getTaskByIdRow(db, taskId);
+		if (!updatedTask) {
+			throw new Error(`Failed to update background task '${taskId}'`);
+		}
+
+		return updatedTask;
+	});
+}
+
+export function getActiveTasks(db: Database, sessionId?: string): readonly BackgroundTaskRecord[] {
+	return listBackgroundTasks(db, {
+		sessionId,
+		statuses: ["pending", "running"],
+		prioritizePending: true,
+	});
+}
+
+export function getTaskById(db: Database, taskId: string): BackgroundTaskRecord | null {
+	return getTaskByIdRow(db, taskId);
+}
+
+export function getTaskResult(db: Database, taskId: string): BackgroundTaskResultRecord | null {
+	const task = getTaskByIdRow(db, taskId);
+	if (!task) {
+		return null;
+	}
+
+	return Object.freeze({
+		status: task.status,
+		result: task.result,
+		error: task.error,
+		completedAt: task.completedAt,
+	});
+}
+
+export function cancelTask(db: Database, taskId: string): BackgroundTaskRecord | null {
+	const task = getTaskByIdRow(db, taskId);
+	if (!task) {
+		return null;
+	}
+
+	if (task.status !== "pending" && task.status !== "running") {
+		return task;
+	}
+
+	return updateStatus(db, taskId, "cancelled");
+}
+
+export function countByStatus(db: Database, status: TaskStatus): number {
+	const row = db
+		.query("SELECT COUNT(*) as count FROM background_tasks WHERE status = ?")
+		.get(status) as { count?: number } | null;
+	return row?.count ?? 0;
+}
+
+export function enforceMaxConcurrent(db: Database, maxConcurrent: number): void {
+	const runningCount = countByStatus(db, "running");
+	if (runningCount >= maxConcurrent) {
+		throw new Error(
+			`Background concurrency limit reached: ${runningCount} running task(s), max ${maxConcurrent}`,
+		);
+	}
+}
+
+export function listTasks(
+	db: Database,
+	filters: { readonly sessionId?: string; readonly status?: TaskStatus } = {},
+): readonly BackgroundTaskRecord[] {
+	return listBackgroundTasks(db, filters);
+}

package/src/background/schema.ts

@@ -0,0 +1,24 @@
+export const BACKGROUND_TASKS_TABLE_STATEMENT = `CREATE TABLE IF NOT EXISTS background_tasks (
+	id TEXT PRIMARY KEY,
+	session_id TEXT NOT NULL,
+	description TEXT NOT NULL,
+	category TEXT,
+	status TEXT NOT NULL DEFAULT 'pending',
+	result TEXT,
+	error TEXT,
+	agent TEXT,
+	model TEXT,
+	priority INTEGER NOT NULL DEFAULT 50,
+	created_at TEXT NOT NULL,
+	updated_at TEXT NOT NULL,
+	started_at TEXT,
+	completed_at TEXT
+)`;
+
+export const BACKGROUND_TASKS_INDEX_STATEMENT =
+	"CREATE INDEX IF NOT EXISTS idx_background_tasks_status_created_at ON background_tasks(status, created_at)";
+
+export const BACKGROUND_TASKS_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
+	BACKGROUND_TASKS_TABLE_STATEMENT,
+	BACKGROUND_TASKS_INDEX_STATEMENT,
+]);

package/src/background/sdk-runner.ts

@@ -0,0 +1,40 @@
+import { getLogger } from "../logging/domains";
+import type { BackgroundTaskRecord } from "./database";
+
+export interface BackgroundSdkOperations {
+	readonly promptAsync: (
+		sessionId: string,
+		model: string | undefined,
+		parts: ReadonlyArray<{ type: "text"; text: string }>,
+	) => Promise<void>;
+}
+
+const logger = getLogger("background", "sdk-runner");
+
+export function createSdkRunner(
+	sdk: BackgroundSdkOperations,
+): (task: BackgroundTaskRecord, signal: AbortSignal) => Promise<string> {
+	return async (task, signal) => {
+		if (signal.aborted) {
+			throw signal.reason ?? new Error("Aborted");
+		}
+
+		const model = task.model ?? undefined;
+		const parts: ReadonlyArray<{ type: "text"; text: string }> = [
+			{ type: "text", text: task.description },
+		];
+
+		logger.info("Dispatching background task via SDK", {
+			backgroundTaskId: task.id,
+			sessionId: task.sessionId,
+			agent: task.agent,
+			model: task.model,
+		});
+
+		await sdk.promptAsync(task.sessionId, model, parts);
+
+		const agentLabel = task.agent ? ` via ${task.agent}` : "";
+		const modelLabel = task.model ? ` (${task.model})` : "";
+		return `Dispatched${agentLabel}${modelLabel}: ${task.description}`;
+	};
+}

package/src/background/slot-manager.ts

@@ -0,0 +1,41 @@
+export class SlotManager {
+	private readonly occupiedSlots = new Set<string>();
+
+	constructor(private readonly maxSlots: number) {
+		if (!Number.isInteger(maxSlots) || maxSlots < 1) {
+			throw new Error("SlotManager requires at least one slot");
+		}
+	}
+
+	acquire(): string | null {
+		if (this.isFull()) {
+			return null;
+		}
+
+		for (let index = 1; index <= this.maxSlots; index += 1) {
+			const slotId = `slot-${index}`;
+			if (!this.occupiedSlots.has(slotId)) {
+				this.occupiedSlots.add(slotId);
+				return slotId;
+			}
+		}
+
+		return null;
+	}
+
+	release(slotId: string): void {
+		this.occupiedSlots.delete(slotId);
+	}
+
+	getActiveCount(): number {
+		return this.occupiedSlots.size;
+	}
+
+	isFull(): boolean {
+		return this.occupiedSlots.size >= this.maxSlots;
+	}
+
+	getCapacity(): number {
+		return this.maxSlots;
+	}
+}

package/src/background/state-machine.ts

@@ -0,0 +1,19 @@
+import type { TaskStatus } from "../types/background";
+
+const VALID_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]>> = Object.freeze({
+	pending: Object.freeze<TaskStatus[]>(["running", "cancelled"]),
+	running: Object.freeze<TaskStatus[]>(["completed", "failed", "cancelled"]),
+	completed: Object.freeze<TaskStatus[]>([]),
+	failed: Object.freeze<TaskStatus[]>([]),
+	cancelled: Object.freeze<TaskStatus[]>([]),
+});
+
+export function validateTransition(from: TaskStatus, to: TaskStatus): boolean {
+	return VALID_TRANSITIONS[from].includes(to);
+}
+
+export function assertTransition(from: TaskStatus, to: TaskStatus): void {
+	if (!validateTransition(from, to)) {
+		throw new Error(`Invalid background task transition from '${from}' to '${to}'`);
+	}
+}

package/src/context/budget.ts

@@ -0,0 +1,45 @@
+import type { ContextSource } from "./types";
+
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_TOTAL_BUDGET = 4000;
+const TRUNCATION_SUFFIX = "... [truncated]";
+
+export function truncateToTokens(content: string, maxTokens: number): string {
+	const maxChars = Math.max(0, Math.floor(maxTokens * CHARS_PER_TOKEN));
+	if (content.length <= maxChars) {
+		return content;
+	}
+
+	if (maxChars === 0) {
+		return "";
+	}
+
+	if (maxChars <= TRUNCATION_SUFFIX.length) {
+		return TRUNCATION_SUFFIX.slice(0, maxChars);
+	}
+
+	const truncatedContent = content.slice(0, maxChars - TRUNCATION_SUFFIX.length).trimEnd();
+	return `${truncatedContent}${TRUNCATION_SUFFIX}`;
+}
+
+export function allocateBudget(
+	sources: readonly ContextSource[],
+	totalBudget: number = DEFAULT_TOTAL_BUDGET,
+): { readonly allocations: ReadonlyMap<string, number>; readonly totalUsed: number } {
+	const orderedSources = [...sources].sort(
+		(left, right) => right.priority - left.priority || left.filePath.localeCompare(right.filePath),
+	);
+	const allocations = new Map<string, number>();
+	let remainingBudget = Math.max(0, totalBudget);
+
+	for (const source of orderedSources) {
+		const allocation = Math.min(source.tokenEstimate, remainingBudget);
+		allocations.set(source.filePath, allocation);
+		remainingBudget -= allocation;
+	}
+
+	return {
+		allocations,
+		totalUsed: Math.max(0, totalBudget) - remainingBudget,
+	};
+}

package/src/context/compaction-handler.ts

@@ -0,0 +1,58 @@
+import { getLogger } from "../logging/domains";
+import type { createContextInjector } from "./injector";
+
+const logger = getLogger("context", "compaction-handler");
+
+interface EventProperties {
+	readonly sessionID?: string;
+	readonly info?: {
+		readonly sessionID?: string;
+		readonly id?: string;
+	};
+}
+
+function extractSessionID(properties: unknown): string | undefined {
+	if (!properties || typeof properties !== "object") {
+		return undefined;
+	}
+
+	const eventProperties = properties as EventProperties;
+	if (typeof eventProperties.sessionID === "string") {
+		return eventProperties.sessionID;
+	}
+
+	if (typeof eventProperties.info?.sessionID === "string") {
+		return eventProperties.info.sessionID;
+	}
+
+	if (typeof eventProperties.info?.id === "string") {
+		return eventProperties.info.id;
+	}
+
+	return undefined;
+}
+
+export function createCompactionHandler(injector: ReturnType<typeof createContextInjector>) {
+	return async (input: {
+		readonly event: {
+			readonly type: string;
+			readonly properties?: unknown;
+		};
+	}): Promise<void> => {
+		try {
+			if (input.event.type !== "session.compacted") {
+				return;
+			}
+
+			const sessionID = extractSessionID(input.event.properties);
+			if (!sessionID) {
+				return;
+			}
+
+			injector.clearCache(sessionID);
+			await injector({ sessionID }, { system: [] });
+		} catch (error) {
+			logger.warn("context compaction handling failed", { error: String(error) });
+		}
+	};
+}

package/src/context/discovery.ts

@@ -0,0 +1,94 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import type { ContextSource, DiscoveryOptions } from "./types";
+
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_MAX_DEPTH = 3;
+const PRIORITY_DEPTH_BONUS = 10;
+
+const CONTEXT_FILE_DEFINITIONS = Object.freeze([
+	Object.freeze({ name: "AGENTS.md", relativePath: "AGENTS.md", priority: 90 }),
+	Object.freeze({ name: "CLAUDE.md", relativePath: "CLAUDE.md", priority: 85 }),
+	Object.freeze({ name: "README.md", relativePath: "README.md", priority: 50 }),
+	Object.freeze({ name: ".opencode/agents.md", relativePath: ".opencode/agents.md", priority: 80 }),
+]);
+
+const discoveryCache = new Map<string, readonly ContextSource[]>();
+
+function createCacheKey(projectRoot: string, maxDepth: number): string {
+	return `${resolve(projectRoot)}::${maxDepth}`;
+}
+
+function buildSearchRoots(projectRoot: string, maxDepth: number): readonly string[] {
+	const roots: string[] = [];
+	let currentRoot = resolve(projectRoot);
+
+	for (let depth = 0; depth <= maxDepth; depth += 1) {
+		roots.push(currentRoot);
+		const parentRoot = dirname(currentRoot);
+		if (parentRoot === currentRoot) {
+			break;
+		}
+		currentRoot = parentRoot;
+	}
+
+	return roots;
+}
+
+function estimateTokens(content: string): number {
+	return Math.ceil(content.length / CHARS_PER_TOKEN);
+}
+
+export function clearContextDiscoveryCache(projectRoot?: string): void {
+	if (!projectRoot) {
+		discoveryCache.clear();
+		return;
+	}
+
+	const projectRootPrefix = `${resolve(projectRoot)}::`;
+	for (const key of discoveryCache.keys()) {
+		if (key.startsWith(projectRootPrefix)) {
+			discoveryCache.delete(key);
+		}
+	}
+}
+
+export async function discoverContextFiles(
+	options: DiscoveryOptions,
+): Promise<readonly ContextSource[]> {
+	const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+	const cacheKey = createCacheKey(options.projectRoot, maxDepth);
+	const cached = discoveryCache.get(cacheKey);
+	if (cached !== undefined) {
+		return cached;
+	}
+
+	const roots = buildSearchRoots(options.projectRoot, maxDepth);
+	const sources: ContextSource[] = [];
+
+	for (const [depth, root] of roots.entries()) {
+		for (const definition of CONTEXT_FILE_DEFINITIONS) {
+			const filePath = join(root, definition.relativePath);
+			try {
+				const content = await readFile(filePath, "utf-8");
+				sources.push({
+					name: definition.name,
+					filePath,
+					content,
+					priority: definition.priority + (maxDepth - depth + 1) * PRIORITY_DEPTH_BONUS,
+					tokenEstimate: estimateTokens(content),
+				});
+			} catch (error: unknown) {
+				if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+					throw error;
+				}
+			}
+		}
+	}
+
+	const orderedSources = [...sources].sort(
+		(left, right) => right.priority - left.priority || left.filePath.localeCompare(right.filePath),
+	);
+	discoveryCache.set(cacheKey, orderedSources);
+	return orderedSources;
+}

package/src/context/index.ts

@@ -0,0 +1,14 @@
+export { allocateBudget, truncateToTokens } from "./budget";
+export { createCompactionHandler } from "./compaction-handler";
+export { clearContextDiscoveryCache, discoverContextFiles } from "./discovery";
+export {
+	type ContextInjector,
+	type ContextInjectorOptions,
+	createContextInjector,
+} from "./injector";
+export type {
+	ContextBudget,
+	ContextInjectionResult,
+	ContextSource,
+	DiscoveryOptions,
+} from "./types";

package/src/context/injector.ts

@@ -0,0 +1,119 @@
+import { getLogger } from "../logging/domains";
+import { allocateBudget, truncateToTokens } from "./budget";
+import { clearContextDiscoveryCache, discoverContextFiles } from "./discovery";
+import type { ContextInjectionResult, ContextSource, DiscoveryOptions } from "./types";
+
+const DEFAULT_TOTAL_BUDGET = 4000;
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+const logger = getLogger("context", "injector");
+
+export interface ContextInjectorOptions {
+	readonly projectRoot: string;
+	readonly totalBudget?: number;
+	readonly ttlMs?: number;
+	readonly now?: () => number;
+	readonly discover?: (options: DiscoveryOptions) => Promise<readonly ContextSource[]>;
+}
+
+interface InjectorInput {
+	readonly sessionID?: string;
+}
+
+interface InjectorOutput {
+	system: string[];
+}
+
+interface CacheEntry {
+	readonly result: ContextInjectionResult;
+	readonly expiresAt: number;
+}
+
+export interface ContextInjector {
+	(input: InjectorInput, output: InjectorOutput): Promise<void>;
+	clearCache(sessionID?: string): void;
+}
+
+function buildInjectionText(
+	sources: readonly ContextSource[],
+	allocations: ReadonlyMap<string, number>,
+): {
+	readonly injectedText: string;
+	readonly truncated: boolean;
+} {
+	let truncated = false;
+	const sections: string[] = [];
+
+	for (const source of sources) {
+		const allocation = allocations.get(source.filePath) ?? 0;
+		if (allocation <= 0) {
+			continue;
+		}
+
+		if (allocation < source.tokenEstimate) {
+			truncated = true;
+		}
+
+		sections.push(
+			`---\n[Source: ${source.name}]\n${truncateToTokens(source.content, allocation)}\n---`,
+		);
+	}
+
+	return {
+		injectedText: sections.length > 0 ? `\n${sections.join("\n")}\n` : "",
+		truncated,
+	};
+}
+
+export function createContextInjector(options: ContextInjectorOptions): ContextInjector {
+	const discover = options.discover ?? discoverContextFiles;
+	const now = options.now ?? Date.now;
+	const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+	const totalBudget = options.totalBudget ?? DEFAULT_TOTAL_BUDGET;
+	const cache = new Map<string, CacheEntry>();
+
+	const injector: ContextInjector = async (input, output) => {
+		try {
+			if (!input.sessionID) {
+				return;
+			}
+
+			const cached = cache.get(input.sessionID);
+			if (cached !== undefined && cached.expiresAt > now()) {
+				if (cached.result.injectedText.length > 0) {
+					output.system.push(cached.result.injectedText);
+				}
+				return;
+			}
+
+			const sources = await discover({ projectRoot: options.projectRoot, maxDepth: 3 });
+			const { allocations, totalUsed } = allocateBudget(sources, totalBudget);
+			const { injectedText, truncated } = buildInjectionText(sources, allocations);
+
+			const result: ContextInjectionResult = {
+				injectedText,
+				sources,
+				totalTokens: totalUsed,
+				truncated,
+			};
+
+			cache.set(input.sessionID, { result, expiresAt: now() + ttlMs });
+
+			if (injectedText.length > 0) {
+				output.system.push(injectedText);
+			}
+		} catch (error) {
+			logger.warn("context injection failed", { error: String(error) });
+		}
+	};
+
+	injector.clearCache = (sessionID?: string) => {
+		if (sessionID) {
+			cache.delete(sessionID);
+		} else {
+			cache.clear();
+		}
+		clearContextDiscoveryCache(options.projectRoot);
+	};
+
+	return injector;
+}

package/src/context/types.ts

@@ -0,0 +1,24 @@
+export interface ContextSource {
+	readonly name: string;
+	readonly filePath: string;
+	readonly content: string;
+	readonly priority: number;
+	readonly tokenEstimate: number;
+}
+
+export interface ContextBudget {
+	readonly totalTokens: number;
+	readonly allocations: ReadonlyMap<string, number>;
+}
+
+export interface ContextInjectionResult {
+	readonly injectedText: string;
+	readonly sources: readonly ContextSource[];
+	readonly totalTokens: number;
+	readonly truncated: boolean;
+}
+
+export interface DiscoveryOptions {
+	readonly projectRoot: string;
+	readonly maxDepth?: number;
+}