omp-onlyne 0.0.0-stage → 0.2.0

package/src/store.ts

@@ -0,0 +1,189 @@
+import { Database } from "bun:sqlite";
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import type { Entry, Storage, ThreadRef, Transaction } from "@onlyne/lib";
+import type { ContextRecord } from "./types.ts";
+import { bridgeText as t } from "./bridge-text.ts";
+
+/** Key/value rows under one SQLite file; the library's durable state and the plugin's registry share it. */
+export class SqliteStorage implements Storage {
+	readonly guarantee = "durable" as const;
+	readonly #db: Database;
+	#tail: Promise<unknown> = Promise.resolve();
+	#closed = false;
+
+	constructor(path: string) {
+		// The store carries trust rows and, while a rotation is unacknowledged, the old private
+		// key that proves it. It is secret material: 0700 for the directory, 0600 for the files,
+		// including the WAL and shared-memory sidecars SQLite creates beside them.
+		const dir = dirname(path);
+		mkdirSync(dir, { recursive: true, mode: 0o700 });
+		chmodSync(dir, 0o700);
+		this.#db = new Database(path, { create: true });
+		this.#db.exec("PRAGMA journal_mode = WAL");
+		this.#db.exec("PRAGMA synchronous = FULL");
+		this.#db.exec("PRAGMA busy_timeout = 5000");
+		this.#db.exec("CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+		for (const file of [path, `${path}-wal`, `${path}-shm`]) {
+			if (existsSync(file)) chmodSync(file, 0o600);
+		}
+	}
+
+	/** Serialize every transaction; SQLite's own BEGIN IMMEDIATE would otherwise race across awaits. */
+	transaction<T>(work: (tx: Transaction) => Promise<T>): Promise<T> {
+		const run = () => this.#execute(work);
+		const result = this.#tail.then(run, run);
+		this.#tail = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	}
+
+	async #execute<T>(work: (tx: Transaction) => Promise<T>): Promise<T> {
+		if (this.#closed) throw new Error(t("storeClosed"));
+		this.#db.exec("BEGIN IMMEDIATE");
+		const tx: Transaction = {
+			get: async <V>(key: string) => this.#get<V>(key),
+			put: async <V>(key: string, value: V) => this.#put(key, value),
+			delete: async (key: string) => {
+				this.#db.query("DELETE FROM kv WHERE key = ?").run(key);
+			},
+			scan: async <V>(prefix: string) => this.#scan<V>(prefix),
+		};
+		try {
+			const value = await work(tx);
+			this.#db.exec("COMMIT");
+			return value;
+		} catch (error) {
+			try {
+				this.#db.exec("ROLLBACK");
+			} catch {
+				// The transaction may already be gone; preserve the original failure.
+			}
+			throw error;
+		}
+	}
+
+	#get<T>(key: string): T | undefined {
+		const row = this.#db.query<{ value: string }, [string]>("SELECT value FROM kv WHERE key = ?").get(key);
+		return row === null ? undefined : (JSON.parse(row.value) as T);
+	}
+
+	#put(key: string, value: unknown): void {
+		this.#db
+			.query("INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+			.run(key, JSON.stringify(value));
+	}
+
+	#scan<T>(prefix: string): Array<{ key: string; value: T }> {
+		const rows = this.#db
+			.query<{ key: string; value: string }, [number, string]>(
+				"SELECT key, value FROM kv WHERE substr(key, 1, ?) = ? ORDER BY key",
+			)
+			.all(prefix.length, prefix);
+		return rows.map(row => ({ key: row.key, value: JSON.parse(row.value) as T }));
+	}
+
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#db.close();
+	}
+}
+
+const COUNTER_KEY = "meta/context-counter";
+const CONTEXT_PREFIX = "context/";
+
+/**
+ * Whether a registered context can answer a delivery. Only the session holding this node's
+ * own send right can: a subagent context reads and drafts, never sends. Advertising one as a
+ * continuation target hands the sender a message nobody there can reply to, and the sender
+ * has no way to see that from the alias (caerulea report 4, problem 7).
+ */
+export function canAnswer(record: ContextRecord): boolean {
+	return record.agent_id !== undefined && record.agent_id === record.main_agent_id;
+}
+
+/** Alias allocation and binding for execution contexts; the store is the authority across restarts. */
+export class ContextRegistry {
+	constructor(private readonly storage: Storage, private readonly nodeId: string, private readonly mainAgentId: string) {}
+
+	/** The main OMP session is addressable like a registered execution context. */
+	async ensureMain(): Promise<ContextRecord> {
+		return this.storage.transaction(async tx => {
+			const key = `${CONTEXT_PREFIX}main`;
+			const current = await tx.get<ContextRecord>(key);
+			if (current !== undefined) return current;
+			const record: ContextRecord = {
+				alias: "main", node_id: this.nodeId, main_agent_id: this.mainAgentId, agent_id: this.mainAgentId,
+				summary: t("mainSummary"), state: "idle", created_at: new Date().toISOString(),
+			};
+			await tx.put(key, record);
+			return record;
+		});
+	}
+
+	async allocate(thread_ref: ThreadRef | undefined, summary: string, source?: Entry["message"]): Promise<ContextRecord> {
+		return this.storage.transaction(async tx => {
+			const counter = (await tx.get<number>(COUNTER_KEY)) ?? 0;
+			const next = counter + 1;
+			await tx.put(COUNTER_KEY, next);
+			const alias = `c-${String(next)}`;
+			const record: ContextRecord = {
+				alias,
+				node_id: this.nodeId,
+				main_agent_id: this.mainAgentId,
+				...(source === undefined ? {} : { source: { sender: source.sender, id: source.id } }),
+				...(thread_ref === undefined ? {} : { thread_ref }),
+				summary,
+				state: "unbound",
+				created_at: new Date().toISOString(),
+			};
+			await tx.put(`${CONTEXT_PREFIX}${alias}`, record);
+			return record;
+		});
+	}
+
+	async bind(
+		alias: string,
+		binding: { agent_id: string; session_file?: string; parent_id?: string },
+	): Promise<ContextRecord> {
+		return this.storage.transaction(async tx => {
+			const key = `${CONTEXT_PREFIX}${alias}`;
+			const current = await tx.get<ContextRecord>(key);
+			if (current === undefined) throw new Error(t("contextNotRegistered", { alias }));
+			const next: ContextRecord = {
+				...current,
+				agent_id: binding.agent_id,
+				...(binding.session_file === undefined ? {} : { session_file: binding.session_file }),
+				...(binding.parent_id === undefined ? {} : { parent_id: binding.parent_id }),
+				state: current.agent_id === binding.agent_id ? current.state : "idle",
+				bound_at: new Date().toISOString(),
+			};
+			await tx.put(key, next);
+			return next;
+		});
+	}
+
+	async find(alias: string): Promise<ContextRecord | undefined> {
+		return this.storage.transaction(tx => tx.get<ContextRecord>(`${CONTEXT_PREFIX}${alias}`));
+	}
+
+	async list(): Promise<ContextRecord[]> {
+		return this.storage.transaction(async tx =>
+			(await tx.scan<ContextRecord>(CONTEXT_PREFIX)).map(row => row.value),
+		);
+	}
+
+	async updateState(alias: string, state: ContextRecord["state"]): Promise<ContextRecord | undefined> {
+		return this.storage.transaction(async tx => {
+			const key = `${CONTEXT_PREFIX}${alias}`;
+			const current = await tx.get<ContextRecord>(key);
+			if (current === undefined) return undefined;
+			const next = { ...current, state };
+			await tx.put(key, next);
+			return next;
+		});
+	}
+}

package/src/tern.ts

@@ -0,0 +1,66 @@
+/**
+ * Tern identity for the bootstrap defaults.
+ *
+ * `TERN_PANE` is the block id the process runs in. `tern ls --json` is the
+ * supported query for the session that owns a block; a missing binary, a
+ * non-zero exit, malformed JSON or an unknown block all return `undefined`.
+ * The caller may fall back to its own default, but this module never guesses a
+ * session name from the cwd or from a prefix.
+ */
+
+interface TernBlock {
+	id?: unknown;
+}
+
+interface TernTab {
+	blocks?: TernBlock[];
+}
+
+interface TernSession {
+	name?: unknown;
+	tabs?: TernTab[];
+}
+
+interface TernList {
+	sessions?: TernSession[];
+}
+
+/** The Tern block this process runs in, when Tern set it. */
+export function detectTernBlock(): string | undefined {
+	const block = process.env.TERN_PANE?.trim();
+	return block === undefined || block.length === 0 ? undefined : block;
+}
+
+/** The session name owning `block` (default: this process's block), `onlyne:` stripped. */
+export function detectTernSession(block: string | undefined = detectTernBlock()): string | undefined {
+	if (block === undefined) return undefined;
+	let output: string;
+	try {
+		const result = Bun.spawnSync([process.env.TERN_ACP ?? "tern", "ls", "--json"], {
+			stdout: "pipe",
+			stderr: "ignore",
+		});
+		if (result.exitCode !== 0) return undefined;
+		output = new TextDecoder().decode(result.stdout);
+	} catch {
+		return undefined;
+	}
+	let parsed: TernList;
+	try {
+		parsed = JSON.parse(output) as TernList;
+	} catch {
+		return undefined;
+	}
+	const sessions = Array.isArray(parsed.sessions) ? parsed.sessions : [];
+	for (const session of sessions) {
+		const tabs = Array.isArray(session.tabs) ? session.tabs : [];
+		for (const tab of tabs) {
+			const blocks = Array.isArray(tab.blocks) ? tab.blocks : [];
+			if (!blocks.some(candidate => String(candidate.id) === block)) continue;
+			if (typeof session.name !== "string") return undefined;
+			const name = session.name.replace(/^onlyne:/, "").trim();
+			return name.length === 0 ? undefined : name;
+		}
+	}
+	return undefined;
+}

package/src/todo-native.ts

@@ -0,0 +1,230 @@
+import type { SessionEntry } from "@oh-my-pi/pi-coding-agent";
+import { USER_TODO_EDIT_CUSTOM_TYPE } from "@oh-my-pi/pi-coding-agent/tools/todo";
+import type { TodoState, TodoStateGoal, TodoStateItem, TodoStatePhase, TodoStatus } from "./todo.ts";
+
+/**
+ * Branch records the structural reader understands. Kept as literals so this
+ * module never imports omp-todo-more; the rich adapter checks the installed
+ * module against them before it writes anything.
+ */
+export const TODO_MORE_ENTRY = "mouriya.omp.todo-more";
+export const TODO_MORE_RESULT_MARK = "todoMore";
+
+/** What `session.setTodoPhases` and the native HUD take. */
+export interface HostTodoTask {
+	content: string;
+	status: TodoStatus;
+	blocker?: string;
+	details?: string;
+	notes?: string[];
+}
+
+export interface HostTodoPhase {
+	name: string;
+	tasks: HostTodoTask[];
+}
+
+const TODO_STATUS: Record<TodoStatus, true> = {
+	pending: true,
+	in_progress: true,
+	completed: true,
+	abandoned: true,
+	blocked: true,
+};
+
+export function isTodoStatus(value: unknown): value is TodoStatus {
+	return typeof value === "string" && Object.hasOwn(TODO_STATUS, value);
+}
+
+interface NativeTask {
+	content: string;
+	status: TodoStatus;
+	blocker?: string;
+	details?: string;
+	notes?: string[];
+}
+
+interface NativePhase {
+	name: string;
+	tasks: NativeTask[];
+}
+
+/**
+ * The host's own todo list on a branch (oldest first): the newest native edit,
+ * joined onto the nearest earlier rich snapshot by title. Rich snapshots only
+ * contribute explanations; statuses, blockers and ordering are native.
+ */
+export function readNativeState(entries: readonly SessionEntry[]): TodoState {
+	const pending: NativePhase[][] = [];
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry === undefined) continue;
+		const rich = richState(entry);
+		if (rich !== undefined) return joinNative(rich, pending);
+		const native = nativeRecord(entry);
+		if (native === undefined) continue;
+		pending.push(native);
+		// An empty native edit clears the list; older records must not resurrect it.
+		if (native.every(phase => phase.tasks.length === 0)) break;
+	}
+	return joinNative({ goal: null, phases: [] }, pending);
+}
+
+/** The titles one native record defines, for pruning Onlyne's origin roster. */
+export function nativeTitles(entry: SessionEntry): Set<string> | undefined {
+	const phases = nativeRecord(entry);
+	if (phases === undefined) return undefined;
+	const titles = new Set<string>();
+	for (const phase of phases) {
+		for (const task of phase.tasks) titles.add(`${phase.name}\u0000${task.content}`);
+	}
+	return titles;
+}
+
+/** The host projection of a state: what `setTodoPhases` persists. */
+export function nativePhases(state: TodoState): HostTodoPhase[] {
+	return state.phases.map(phase => ({
+		name: phase.name,
+		tasks: phase.items.map(item => ({
+			content: item.title,
+			status: item.status,
+			...(item.blocker === undefined ? {} : { blocker: item.blocker }),
+			...(item.details === undefined ? {} : { details: item.details }),
+			...(item.notes === undefined ? {} : { notes: item.notes }),
+		})),
+	}));
+}
+
+function joinNative(base: TodoState, pendingNewestFirst: NativePhase[][]): TodoState {
+	return pendingNewestFirst.reduceRight((state, phases) => {
+		const known = new Map<string, TodoStateItem>();
+		for (const phase of state.phases) {
+			for (const item of phase.items) known.set(item.title, item);
+		}
+		const joined: TodoStatePhase[] = phases.map(phase => ({
+			name: phase.name,
+			items: phase.tasks.map(task => {
+				const previous = known.get(task.content);
+				const details = task.details ?? previous?.details;
+				const notes = task.notes ?? previous?.notes;
+				return {
+					title: task.content,
+					status: task.status,
+					...(previous?.explanation === undefined ? {} : { explanation: previous.explanation }),
+					...(task.blocker === undefined ? {} : { blocker: task.blocker }),
+					...(details === undefined ? {} : { details }),
+					...(notes === undefined ? {} : { notes }),
+				};
+			}),
+		}));
+		let count = 0;
+		for (const phase of joined) count += phase.items.length;
+		return count === 0 ? { goal: null, phases: [] } : { goal: state.goal, phases: joined };
+	}, base);
+}
+
+function richState(entry: SessionEntry): TodoState | undefined {
+	if (entry.type !== "custom" || entry.customType !== TODO_MORE_ENTRY) return undefined;
+	const phases = recordField(entry.data, "phases");
+	if (!Array.isArray(phases)) return undefined;
+	const parsed: TodoStatePhase[] = [];
+	for (const phase of phases) {
+		const name = stringField(phase, "name");
+		const items = recordField(phase, "items");
+		if (name === undefined || !Array.isArray(items)) return undefined;
+		const parsedItems: TodoStateItem[] = [];
+		for (const item of items) {
+			const title = stringField(item, "title");
+			const status = recordField(item, "status");
+			if (title === undefined || !isTodoStatus(status)) return undefined;
+			const explanation = stringField(item, "explanation");
+			const blocker = stringField(item, "blocker");
+			parsedItems.push({
+				title,
+				status,
+				...(explanation === undefined ? {} : { explanation }),
+				...(blocker === undefined ? {} : { blocker }),
+			});
+		}
+		parsed.push({ name, items: parsedItems });
+	}
+	const goal = richGoal(recordField(entry.data, "goal"));
+	if (goal === undefined) return undefined;
+	let count = 0;
+	for (const phase of parsed) count += phase.items.length;
+	return count === 0 ? { goal: null, phases: [] } : { goal, phases: parsed };
+}
+
+/** `null` means the snapshot carries no goal; `undefined` means it is malformed. */
+function richGoal(value: unknown): TodoStateGoal | null | undefined {
+	if (value === null || value === undefined) return null;
+	const objective = stringField(value, "objective");
+	const measure = stringField(value, "measure");
+	const doneWhen = stringField(value, "doneWhen");
+	if (objective === undefined || measure === undefined || doneWhen === undefined) return undefined;
+	if (objective.trim().length === 0 || measure.trim().length === 0 || doneWhen.trim().length === 0) return undefined;
+	return { objective, measure, doneWhen };
+}
+
+function nativeRecord(entry: SessionEntry): NativePhase[] | undefined {
+	if (entry.type === "custom") {
+		if (entry.customType !== USER_TODO_EDIT_CUSTOM_TYPE) return undefined;
+		return parseNativePhases(recordField(entry.data, "phases"));
+	}
+	if (entry.type !== "message") return undefined;
+	const message = entry.message as unknown as {
+		role?: unknown;
+		toolName?: unknown;
+		isError?: unknown;
+		details?: { op?: unknown; phases?: unknown; [TODO_MORE_RESULT_MARK]?: unknown };
+	};
+	if (message.role !== "toolResult" || message.toolName !== "todo" || message.isError === true) return undefined;
+	if (message.details?.op === "view") return undefined;
+	// todo-more's own results follow the entry that records them.
+	if (message.details?.[TODO_MORE_RESULT_MARK] === true) return undefined;
+	return parseNativePhases(message.details?.phases);
+}
+
+function parseNativePhases(value: unknown): NativePhase[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const phases: NativePhase[] = [];
+	for (const phase of value) {
+		const name = stringField(phase, "name");
+		const tasks = recordField(phase, "tasks");
+		if (name === undefined || !Array.isArray(tasks)) return undefined;
+		const parsed: NativeTask[] = [];
+		for (const task of tasks) {
+			const content = stringField(task, "content");
+			const status = recordField(task, "status");
+			if (content === undefined || !isTodoStatus(status)) return undefined;
+			const blocker = stringField(task, "blocker");
+			const details = stringField(task, "details");
+			const notes = stringListField(task, "notes");
+			parsed.push({
+				content,
+				status,
+				...(blocker === undefined ? {} : { blocker }),
+				...(details === undefined ? {} : { details }),
+				...(notes === undefined ? {} : { notes }),
+			});
+		}
+		phases.push({ name, tasks: parsed });
+	}
+	return phases;
+}
+
+function stringListField(value: unknown, field: string): string[] | undefined {
+	const list = recordField(value, field);
+	if (!Array.isArray(list)) return undefined;
+	return list.every(entry => typeof entry === "string") ? (list as string[]) : undefined;
+}
+
+export function recordField(value: unknown, field: string): unknown {
+	if (value === null || typeof value !== "object") return undefined;
+	return (value as Record<string, unknown>)[field];
+}
+
+export function stringField(value: unknown, field: string): string | undefined {
+	const text = recordField(value, field);
+	return typeof text === "string" ? text : undefined;
+}