@oh-my-pi/pi-coding-agent 15.8.3 → 15.9.1

package/src/session/indexed-session-storage.ts

@@ -0,0 +1,430 @@
+import { toError } from "@oh-my-pi/pi-utils";
+import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+
+export interface SessionStorageIndexEntry {
+	path: string;
+	size: number;
+	mtimeMs: number;
+}
+
+export interface SessionStorageBackend {
+	init(): Promise<void>;
+	loadIndex(): Promise<Iterable<SessionStorageIndexEntry>>;
+	readFull(path: string): Promise<string | null>;
+	readSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
+	writeFull(path: string, content: string, mtimeMs: number): Promise<void>;
+	append(path: string, line: string, mtimeMs: number): Promise<void>;
+	truncate(path: string, mtimeMs: number): Promise<void>;
+	remove(paths: string[]): Promise<void>;
+	move(src: string, dst: string, mtimeMs: number): Promise<void>;
+}
+
+interface IndexEntry {
+	size: number;
+	mtimeMs: number;
+}
+
+interface EnqueueOptions {
+	trackDrain: boolean;
+}
+
+const RESOLVED = Promise.resolve();
+
+function enoent(p: string): NodeJS.ErrnoException {
+	const err = new Error(`ENOENT: no such file, '${p}'`) as NodeJS.ErrnoException;
+	err.code = "ENOENT";
+	err.errno = -2;
+	err.path = p;
+	err.syscall = "open";
+	return err;
+}
+
+function matchesGlob(name: string, pattern: string): boolean {
+	if (pattern === "*") return true;
+	if (pattern.startsWith("*.")) return name.endsWith(pattern.slice(1));
+	return name === pattern;
+}
+
+function byteLength(text: string): number {
+	return Buffer.byteLength(text, "utf-8");
+}
+
+function normalizeByteLimit(maxBytes: number): number {
+	if (!(maxBytes > 0)) return 0;
+	return Math.trunc(maxBytes);
+}
+
+function uniquePaths(paths: readonly string[]): string[] {
+	const out: string[] = [];
+	const seen = new Set<string>();
+	for (const path of paths) {
+		if (seen.has(path)) continue;
+		seen.add(path);
+		out.push(path);
+	}
+	return out;
+}
+
+export class IndexedSessionStorage implements SessionStorage {
+	readonly #backend: SessionStorageBackend;
+	readonly #index = new Map<string, IndexEntry>();
+	readonly #writers = new Set<IndexedSessionStorageWriter>();
+	readonly #pathTails = new Map<string, Promise<void>>();
+	readonly #pathPending = new Map<string, Promise<void>>();
+	readonly #drainPending = new Set<Promise<void>>();
+	#nextMtimeMs = 0;
+	#firstDrainError: Error | undefined;
+
+	constructor(backend: SessionStorageBackend) {
+		this.#backend = backend;
+	}
+
+	async initialize(): Promise<void> {
+		await this.#backend.init();
+		await this.refresh();
+	}
+
+	async refresh(): Promise<void> {
+		await this.drain();
+		const rows = await this.#backend.loadIndex();
+		this.#index.clear();
+		for (const row of rows) {
+			this.#setIndex(row.path, row.size, row.mtimeMs);
+		}
+	}
+
+	async drain(): Promise<void> {
+		while (this.#drainPending.size > 0) {
+			await Promise.allSettled(this.#drainPending);
+		}
+		const error = this.#firstDrainError;
+		this.#firstDrainError = undefined;
+		if (error) throw error;
+	}
+
+	ensureDirSync(_dir: string): void {
+		// Indexed backends are flat: directories are derived from key prefixes.
+	}
+
+	existsSync(path: string): boolean {
+		return this.#index.has(path);
+	}
+
+	writeTextSync(path: string, content: string): void {
+		const mtimeMs = this.#allocMtimeMs();
+		this.#setIndex(path, byteLength(content), mtimeMs);
+		this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs), { trackDrain: true });
+	}
+
+	statSync(path: string): SessionStorageStat {
+		const entry = this.#index.get(path);
+		if (!entry) throw enoent(path);
+		return {
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+			mtime: new Date(entry.mtimeMs),
+		};
+	}
+
+	listFilesSync(dir: string, pattern: string): string[] {
+		const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+		const out: string[] = [];
+		for (const path of this.#index.keys()) {
+			if (!path.startsWith(prefix)) continue;
+			const name = path.slice(prefix.length);
+			if (name.includes("/") || name.includes("\\")) continue;
+			if (!matchesGlob(name, pattern)) continue;
+			out.push(path);
+		}
+		return out;
+	}
+
+	exists(path: string): Promise<boolean> {
+		return Promise.resolve(this.existsSync(path));
+	}
+
+	async readText(path: string): Promise<string> {
+		if (!this.#index.has(path)) throw enoent(path);
+		await this.#awaitPath(path);
+		const content = await this.#backend.readFull(path);
+		if (content === null) throw enoent(path);
+		return content;
+	}
+
+	async readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]> {
+		if (!this.#index.has(path)) throw enoent(path);
+		const prefixLimit = normalizeByteLimit(prefixBytes);
+		const suffixLimit = normalizeByteLimit(suffixBytes);
+		if (prefixLimit === 0 && suffixLimit === 0) return ["", ""];
+		await this.#awaitPath(path);
+		return this.#backend.readSlices(path, prefixLimit, suffixLimit);
+	}
+
+	async writeText(path: string, content: string): Promise<void> {
+		await this.#awaitPath(path);
+		const previous = this.#index.get(path);
+		const mtimeMs = this.#allocMtimeMs();
+		this.#setIndex(path, byteLength(content), mtimeMs);
+		try {
+			await this.#enqueuePath(path, () => this.#backend.writeFull(path, content, mtimeMs), { trackDrain: false });
+		} catch (err) {
+			this.#restoreIndex(path, previous);
+			throw toError(err);
+		}
+	}
+
+	async rename(src: string, dst: string): Promise<void> {
+		await this.#awaitPath(src);
+		await this.#awaitPath(dst);
+		const entry = this.#index.get(src);
+		if (!entry) throw enoent(src);
+		const dstPrevious = this.#index.get(dst);
+		this.#index.delete(src);
+		this.#index.set(dst, { ...entry });
+		try {
+			await this.#enqueuePaths([src, dst], () => this.#backend.move(src, dst, entry.mtimeMs), { trackDrain: false });
+		} catch (err) {
+			this.#index.delete(dst);
+			this.#restoreIndex(dst, dstPrevious);
+			this.#index.set(src, entry);
+			throw toError(err);
+		}
+	}
+
+	async unlink(path: string): Promise<void> {
+		await this.#awaitPath(path);
+		const previous = this.#index.get(path);
+		if (!previous) throw enoent(path);
+		this.#index.delete(path);
+		try {
+			await this.#enqueuePath(path, () => this.#backend.remove([path]), { trackDrain: false });
+		} catch (err) {
+			this.#index.set(path, previous);
+			throw toError(err);
+		}
+	}
+
+	async deleteSessionWithArtifacts(sessionPath: string): Promise<void> {
+		await this.#awaitPath(sessionPath);
+		const sessionEntry = this.#index.get(sessionPath);
+		if (!sessionEntry) throw enoent(sessionPath);
+
+		const artifactsDir = sessionPath.slice(0, -6);
+		const prefix = artifactsDir.endsWith("/") ? artifactsDir : `${artifactsDir}/`;
+		const paths = [sessionPath];
+		for (const key of this.#index.keys()) {
+			if (key.startsWith(prefix)) paths.push(key);
+		}
+
+		for (const path of paths) await this.#awaitPath(path);
+
+		const previous = new Map<string, IndexEntry>();
+		for (const path of paths) {
+			const entry = this.#index.get(path);
+			if (entry) previous.set(path, entry);
+			this.#index.delete(path);
+		}
+
+		try {
+			await this.#enqueuePaths(paths, () => this.#backend.remove(paths), { trackDrain: false });
+		} catch (err) {
+			for (const [path, entry] of previous) this.#index.set(path, entry);
+			throw toError(err);
+		}
+	}
+
+	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
+		const writer = new IndexedSessionStorageWriter(this, path, options);
+		this.#writers.add(writer);
+		return writer;
+	}
+
+	_writerClosed(writer: IndexedSessionStorageWriter): void {
+		this.#writers.delete(writer);
+	}
+
+	_truncateForWriter(path: string): number {
+		const mtimeMs = this.#allocMtimeMs();
+		this.#setIndex(path, 0, mtimeMs);
+		return mtimeMs;
+	}
+
+	_queueTruncate(path: string, mtimeMs: number, getError?: () => Error | undefined): Promise<void> {
+		return this.#enqueuePath(
+			path,
+			async () => {
+				const error = getError?.();
+				if (error) throw error;
+				await this.#backend.truncate(path, mtimeMs);
+			},
+			{ trackDrain: true },
+		);
+	}
+
+	_appendForWriter(path: string, line: string): number {
+		const mtimeMs = this.#allocMtimeMs();
+		const existing = this.#index.get(path);
+		const size = (existing?.size ?? 0) + byteLength(line);
+		this.#setIndex(path, size, mtimeMs);
+		return mtimeMs;
+	}
+
+	_queueAppend(path: string, line: string, mtimeMs: number, getError?: () => Error | undefined): Promise<void> {
+		return this.#enqueuePath(
+			path,
+			async () => {
+				const error = getError?.();
+				if (error) throw error;
+				await this.#backend.append(path, line, mtimeMs);
+			},
+			{ trackDrain: true },
+		);
+	}
+
+	#restoreIndex(path: string, entry: IndexEntry | undefined): void {
+		if (entry) {
+			this.#index.set(path, entry);
+		} else {
+			this.#index.delete(path);
+		}
+	}
+
+	#setIndex(path: string, size: number, mtimeMs: number): void {
+		this.#index.set(path, { size, mtimeMs });
+		if (mtimeMs > this.#nextMtimeMs) this.#nextMtimeMs = mtimeMs;
+	}
+
+	#allocMtimeMs(): number {
+		const now = Date.now();
+		const next = now > this.#nextMtimeMs ? now : this.#nextMtimeMs + 1;
+		this.#nextMtimeMs = next;
+		return next;
+	}
+
+	#enqueuePath(path: string, task: () => Promise<void>, options: EnqueueOptions): Promise<void> {
+		return this.#enqueuePaths([path], task, options);
+	}
+
+	#enqueuePaths(paths: readonly string[], task: () => Promise<void>, options: EnqueueOptions): Promise<void> {
+		const unique = uniquePaths(paths);
+		const previous = unique.map(path => this.#pathTails.get(path) ?? RESOLVED);
+		const operation = Promise.all(previous).then(task);
+		const tracked = operation.catch(err => {
+			const error = toError(err);
+			if (options.trackDrain && !this.#firstDrainError) this.#firstDrainError = error;
+			throw error;
+		});
+		const tail = tracked.catch(() => {});
+		for (const path of unique) {
+			this.#pathTails.set(path, tail);
+			this.#pathPending.set(path, tracked);
+		}
+		tail.finally(() => {
+			for (const path of unique) {
+				if (this.#pathTails.get(path) === tail) this.#pathTails.delete(path);
+			}
+		});
+		tracked
+			.finally(() => {
+				for (const path of unique) {
+					if (this.#pathPending.get(path) === tracked) this.#pathPending.delete(path);
+				}
+			})
+			.catch(() => {});
+		tracked.catch(() => {});
+		if (options.trackDrain) {
+			this.#drainPending.add(tracked);
+			tracked
+				.finally(() => {
+					this.#drainPending.delete(tracked);
+				})
+				.catch(() => {});
+		}
+		return tracked;
+	}
+
+	#awaitPath(path: string): Promise<void> {
+		return this.#pathPending.get(path) ?? RESOLVED;
+	}
+}
+
+class IndexedSessionStorageWriter implements SessionStorageWriter {
+	#storage: IndexedSessionStorage;
+	#path: string;
+	#closed = false;
+	#error: Error | undefined;
+	#onError: ((err: Error) => void) | undefined;
+	#pendingChain: Promise<void> = Promise.resolve();
+
+	constructor(
+		storage: IndexedSessionStorage,
+		path: string,
+		options?: { flags?: "a" | "w"; onError?: (err: Error) => void },
+	) {
+		this.#storage = storage;
+		this.#path = path;
+		this.#onError = options?.onError;
+		if ((options?.flags ?? "a") === "w") {
+			const mtimeMs = storage._truncateForWriter(path);
+			this.#trackPromise(storage._queueTruncate(path, mtimeMs, () => this.#error));
+		}
+	}
+
+	#recordError(err: unknown): Error {
+		const error = toError(err);
+		if (!this.#error) this.#error = error;
+		this.#onError?.(error);
+		return error;
+	}
+
+	#trackPromise(promise: Promise<void>): Promise<void> {
+		const next = this.#pendingChain.then(async () => {
+			if (this.#error) throw this.#error;
+			try {
+				await promise;
+			} catch (err) {
+				throw this.#recordError(err);
+			}
+		});
+		this.#pendingChain = next.catch(() => {});
+		return next;
+	}
+
+	writeLineSync(line: string): void {
+		if (this.#closed) throw new Error("Writer closed");
+		if (this.#error) throw this.#error;
+		const mtimeMs = this.#storage._appendForWriter(this.#path, line);
+		this.#trackPromise(this.#storage._queueAppend(this.#path, line, mtimeMs, () => this.#error));
+	}
+
+	async writeLine(line: string): Promise<void> {
+		if (this.#closed) throw new Error("Writer closed");
+		if (this.#error) throw this.#error;
+		const mtimeMs = this.#storage._appendForWriter(this.#path, line);
+		await this.#trackPromise(this.#storage._queueAppend(this.#path, line, mtimeMs, () => this.#error));
+	}
+
+	async flush(): Promise<void> {
+		if (this.#error) throw this.#error;
+		await this.#pendingChain;
+		if (this.#error) throw this.#error;
+	}
+
+	async fsync(): Promise<void> {
+		await this.flush();
+	}
+
+	async close(): Promise<void> {
+		if (this.#closed) return;
+		this.#closed = true;
+		try {
+			await this.flush();
+		} finally {
+			this.#storage._writerClosed(this);
+		}
+	}
+
+	getError(): Error | undefined {
+		return this.#error;
+	}
+}

package/src/session/messages.ts

@@ -18,7 +18,10 @@ import type {
 	MessageAttribution,
 	TextContent,
 	ToolResultMessage,
+	UserMessage,
 } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
+import userInterjectionTemplate from "../prompts/steering/user-interjection.md" with { type: "text" };
 
 export {
 	type BranchSummaryMessage,
@@ -105,6 +108,83 @@ export function stripInternalDetailsFields<T>(details: T | undefined): T | undef
 	return cleaned as T;
 }
 
+function isSteeringUserMessage(message: AgentMessage | undefined): message is UserMessage & { steering: true } {
+	return message?.role === "user" && message.steering === true;
+}
+
+function userMessageWithoutSteering(message: UserMessage): UserMessage {
+	const { steering, ...rest } = message;
+	void steering;
+	return rest;
+}
+
+function renderSteeringEnvelope(message: string): string {
+	return prompt.render(userInterjectionTemplate, { message });
+}
+
+function getArrayContentText(content: (TextContent | ImageContent)[]): string {
+	let firstText: string | undefined;
+	let textParts: string[] | undefined;
+	for (const part of content) {
+		if (part.type !== "text") continue;
+		if (firstText === undefined) {
+			firstText = part.text;
+			continue;
+		}
+		if (textParts === undefined) {
+			textParts = [firstText];
+		}
+		textParts.push(part.text);
+	}
+	return textParts === undefined ? (firstText ?? "") : textParts.join("\n");
+}
+
+function getArrayContentImages(content: (TextContent | ImageContent)[]): ImageContent[] {
+	let images: ImageContent[] | undefined;
+	for (const part of content) {
+		if (part.type !== "image") continue;
+		if (images === undefined) images = [];
+		images.push(part);
+	}
+	return images ?? [];
+}
+
+function wrapSteeringUserMessage(message: UserMessage): UserMessage {
+	if (typeof message.content === "string") {
+		if (message.content.length === 0) return message;
+		return { ...userMessageWithoutSteering(message), content: renderSteeringEnvelope(message.content) };
+	}
+
+	const text = getArrayContentText(message.content);
+	if (text.length === 0) return message;
+	const content: (TextContent | ImageContent)[] = [{ type: "text", text: renderSteeringEnvelope(text) }];
+	content.push(...getArrayContentImages(message.content));
+	return { ...userMessageWithoutSteering(message), content };
+}
+
+export function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[] {
+	const last = messages[messages.length - 1];
+	if (!isSteeringUserMessage(last)) return messages;
+
+	let firstSteer = messages.length - 1;
+	while (firstSteer > 0 && isSteeringUserMessage(messages[firstSteer - 1])) {
+		firstSteer--;
+	}
+
+	let wrappedMessages: AgentMessage[] | undefined;
+	for (let i = firstSteer; i < messages.length; i++) {
+		const message = messages[i];
+		if (!isSteeringUserMessage(message)) continue;
+		const wrappedMessage = wrapSteeringUserMessage(message);
+		if (wrappedMessage === message) continue;
+		if (wrappedMessages === undefined) {
+			wrappedMessages = messages.slice();
+		}
+		wrappedMessages[i] = wrappedMessage;
+	}
+	return wrappedMessages ?? messages;
+}
+
 function getPrunedToolResultContent(message: ToolResultMessage): (TextContent | ImageContent)[] {
 	if (message.prunedAt === undefined) {
 		return message.content;