@zetaloop/chappie 0.2.1 → 0.3.1

package/src/session.ts

@@ -1,14 +1,18 @@
 import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join } from "node:path";
 import type {
 	AssistantMessage,
-	Context,
 	ToolResultMessage,
 	UserMessage,
 } from "@earendil-works/pi-ai";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
+	SessionEntry,
 } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import type { DeliveryRecord } from "./delivery.ts";
 import {
 	type BrokerMessage,
@@ -23,6 +27,11 @@ import { readSessionResource, rememberImages } from "./resources.ts";
 
 type RemoteRequest = Extract<BrokerMessage, { type: "chat" | "call" }>;
 
+interface Notice {
+	message: string;
+	type: "info" | "warning" | "error";
+}
+
 interface SyncRequest {
 	resolve(): void;
 	reject(error: Error): void;
@@ -38,17 +47,17 @@ interface ActiveRequest {
 	session: SessionDescription;
 	message: AssistantMessage;
 	completed: boolean;
-	cancelled: boolean;
+	cancelled: string | undefined;
 	toolResults: ToolResultMessage[];
 }
 
 export class LocalSession {
 	readonly #pi: ExtensionAPI;
 	readonly #agentDir: string;
+	readonly #connect: string | undefined;
 	readonly #syncs = new Map<number, SyncRequest>();
 	readonly #stores = new Map<string, StoreRequest>();
 	readonly #queue: RemoteRequest[] = [];
-	readonly #seenInputs = new Set<string>();
 	readonly #pendingInputs = new Map<string, SessionInput>();
 	readonly #deliveries = new Map<string, DeliveryRecord>();
 	#context: ExtensionContext | undefined;
@@ -59,14 +68,27 @@ export class LocalSession {
 	#nextSyncId = 1;
 	#starting = false;
 	#sessionId: string | undefined;
+	#inputCursor: string | null = null;
 	#flushing = Promise.resolve();
 
-	constructor(pi: ExtensionAPI, agentDir: string) {
+	constructor(pi: ExtensionAPI, agentDir: string, connect?: string) {
 		this.#pi = pi;
 		this.#agentDir = agentDir;
+		this.#connect = connect;
 	}
 
 	install(): void {
+		this.#pi.registerEntryRenderer<Notice>(
+			"chappie.notice",
+			({ data }, _options, theme) => {
+				if (!data) return;
+				return new Text(
+					theme.fg(data.type === "info" ? "dim" : data.type, data.message),
+					1,
+					0,
+				);
+			},
+		);
 		this.#pi.on("session_start", (_event, context) => this.#update(context));
 		this.#pi.on("model_select", (event, context) =>
 			this.#update(context, event.model.provider === "chappie"),
@@ -75,11 +97,21 @@ export class LocalSession {
 			this.#context = context;
 			void this.#sync().catch(() => {});
 		});
-		this.#pi.on("context", (event) => ({
-			messages: event.messages.filter(
-				(message) =>
-					message.role !== "custom" || message.customType !== "chappie.request",
-			),
+		this.#pi.on("session_tree", (event, context) => {
+			this.#context = context;
+			if (context.model?.provider === "chappie") {
+				this.#resetInputs(context, event.newLeafId);
+			}
+		});
+		this.#pi.on("context", (event, context) => ({
+			messages:
+				context.model?.provider === "chappie"
+					? []
+					: event.messages.filter(
+							(message) =>
+								message.role !== "custom" ||
+								message.customType !== "chappie.request",
+						),
 		}));
 		this.#pi.on("turn_end", (event, context) =>
 			this.#turnEnd(event.message, event.toolResults, context),
@@ -94,10 +126,12 @@ export class LocalSession {
 		this.#pi.on("session_shutdown", () => this.close());
 	}
 
-	async start(
-		output: ProviderOutput,
-		_providerContext: Context,
-	): Promise<void> {
+	#notify(message: string, type: Notice["type"] = "info"): void {
+		if (this.#context)
+			this.#pi.appendEntry<Notice>("chappie.notice", { message, type });
+	}
+
+	async start(output: ProviderOutput): Promise<void> {
 		const context = this.#context;
 		const connection = this.#connection;
 		if (context?.model?.provider !== "chappie" || !connection) {
@@ -142,6 +176,7 @@ export class LocalSession {
 		this.#connection?.close();
 		this.#connection = undefined;
 		this.#context = undefined;
+		this.#resetInputs();
 		this.#rejectSyncs(new Error("Chappie session ended"));
 		this.#rejectStores(new Error("Chappie session ended"));
 	}
@@ -155,8 +190,12 @@ export class LocalSession {
 			this.close();
 			return;
 		}
+		if (this.#sessionId !== context.sessionManager.getSessionId()) {
+			this.#resetInputs(context);
+		}
 		if (!this.#connection) {
-			this.#connection = new IpcClient(this.#agentDir, {
+			this.#notify("Connecting to Chappie…");
+			this.#connection = new IpcClient(this.#agentDir, this.#connect, {
 				onOpen: async () => {
 					await this.#sync();
 					await this.#flushDeliveries();
@@ -165,7 +204,8 @@ export class LocalSession {
 				onClose: (error) => {
 					this.#rejectSyncs(error);
 					this.#rejectStores(error);
-					this.#output?.fail(error);
+					if (this.#output && !this.#output.closed) this.#output.fail(error);
+					else this.#notify(error.message, "error");
 					this.#active = undefined;
 					this.#queue.length = 0;
 					this.#starting = false;
@@ -182,13 +222,12 @@ export class LocalSession {
 		const context = this.#context;
 		if (!context) throw new Error("Chappie session is not available");
 		const name = this.#pi.getSessionName();
-		const sessionFile = context.sessionManager.getSessionFile();
 		return {
 			id: context.sessionManager.getSessionId(),
 			cwd: context.cwd,
+			device: hostname(),
 			status: this.#status,
 			...(name ? { name } : {}),
-			...(sessionFile ? { sessionFile } : {}),
 		};
 	}
 
@@ -219,13 +258,24 @@ export class LocalSession {
 			case "stored":
 				this.#stores.get(message.id)?.resolve();
 				break;
+			case "notice":
+				if (
+					message.sessionId === this.#context?.sessionManager.getSessionId()
+				) {
+					this.#notify(message.message);
+				}
+				break;
 			case "inspect":
-				await this.#reply(message.id, message.sessionId, () => ({
-					type: "result",
-					id: message.id,
-					inspection: this.#inspection(),
-					inputs: this.#inputs(),
-				}));
+				await this.#reply(message.id, message.sessionId, async () => {
+					const globalAgents = await this.#readGlobalAgents();
+					return {
+						type: "result",
+						id: message.id,
+						inspection: this.#inspection(),
+						inputs: this.#inputs(),
+						...(globalAgents ? { globalAgents } : {}),
+					};
+				});
 				break;
 			case "ackInputs":
 				if (
@@ -245,13 +295,28 @@ export class LocalSession {
 				const queued = this.#queue.findIndex(
 					(request) => request.id === message.id,
 				);
+				const request =
+					this.#queue[queued] ??
+					(this.#active?.request.id === message.id
+						? this.#active.request
+						: undefined);
+				if (!request) break;
+				const name =
+					request.type === "call"
+						? [...new Set(request.calls.map((call) => call.name))].join(", ")
+						: "chat";
+				this.#notify(
+					`${name} cancelled for ChatGPT ${request.chatId.slice(-4)}: ${message.reason}`,
+					"warning",
+				);
 				if (queued !== -1) {
 					this.#queue.splice(queued, 1);
 					break;
 				}
-				if (this.#active?.request.id !== message.id) break;
-				this.#active.cancelled = true;
-				if (this.#active.completed) await this.#completeActive();
+				const active = this.#active;
+				if (!active) break;
+				active.cancelled = message.reason;
+				if (active.completed) await this.#completeActive();
 				else this.#context?.abort();
 				break;
 			}
@@ -286,6 +351,15 @@ export class LocalSession {
 		};
 	}
 
+	async #readGlobalAgents(): Promise<string | undefined> {
+		try {
+			return await readFile(join(this.#agentDir, "AGENTS.md"), "utf8");
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+			throw error;
+		}
+	}
+
 	#dispatch(): void {
 		if (this.#active) return;
 		const request = this.#queue[0];
@@ -302,7 +376,7 @@ export class LocalSession {
 			session: this.#description(),
 			message: output.message,
 			completed: false,
-			cancelled: false,
+			cancelled: undefined,
 			toolResults: [],
 		};
 		this.#status = "executing";
@@ -355,26 +429,17 @@ export class LocalSession {
 		if (!active?.completed) return;
 		this.#collectInputs();
 		const inputs = this.#inputs();
-		if (active.cancelled) {
-			const sessionFile = active.session.sessionFile;
+		if (active.cancelled !== undefined) {
 			const delivery: DeliveryRecord = {
 				id: randomUUID(),
 				chatId: active.request.chatId,
 				sessionId: active.session.id,
 				cwd: active.session.cwd,
-				toolCallIds:
-					active.request.type === "call"
-						? active.request.calls.map(({ id }) => id)
-						: [],
-				...(sessionFile
-					? { sessionFile }
-					: { inlineResults: active.toolResults }),
-				...(active.message.errorMessage
-					? { error: active.message.errorMessage }
-					: { error: "Request cancelled" }),
+				toolResults: active.toolResults,
+				error: active.cancelled,
 			};
 			this.#deliveries.set(delivery.id, delivery);
-			await this.#flushDeliveries().catch(() => {});
+			void this.#flushDeliveries().catch(() => {});
 		} else {
 			await this.#connection?.send({
 				type: "result",
@@ -392,29 +457,47 @@ export class LocalSession {
 		void this.#sync().catch(() => {});
 	}
 
+	#resetInputs(
+		context?: ExtensionContext,
+		cursor = context?.sessionManager.getLeafId() ?? null,
+	): void {
+		this.#sessionId = context?.sessionManager.getSessionId();
+		this.#inputCursor = cursor;
+		this.#pendingInputs.clear();
+	}
+
 	#collectInputs(): void {
 		const context = this.#context;
 		if (!context) return;
-		const sessionId = context.sessionManager.getSessionId();
+		const sessionManager = context.sessionManager;
+		const sessionId = sessionManager.getSessionId();
 		if (this.#sessionId !== sessionId) {
-			this.#sessionId = sessionId;
-			this.#seenInputs.clear();
-			this.#pendingInputs.clear();
+			this.#resetInputs(context);
+			return;
+		}
+		const leafId = sessionManager.getLeafId();
+		if (leafId === this.#inputCursor) return;
+		const entries: SessionEntry[] = [];
+		let current = sessionManager.getLeafEntry();
+		while (current && current.id !== this.#inputCursor) {
+			entries.push(current);
+			current = current.parentId
+				? sessionManager.getEntry(current.parentId)
+				: undefined;
+		}
+		if (this.#inputCursor !== null && !current) {
+			this.#resetInputs(context);
+			return;
 		}
-		for (const entry of context.sessionManager.getBranch()) {
-			if (
-				entry.type !== "message" ||
-				entry.message.role !== "user" ||
-				this.#seenInputs.has(entry.id)
-			)
-				continue;
+		for (const entry of entries.reverse()) {
+			if (entry.type !== "message" || entry.message.role !== "user") continue;
 			const message = entry.message as UserMessage;
 			if (typeof message.content !== "string") {
 				rememberImages(sessionId, message.content);
 			}
-			this.#seenInputs.add(entry.id);
 			this.#pendingInputs.set(entry.id, { id: entry.id, sessionId, message });
 		}
+		this.#inputCursor = leafId;
 	}
 
 	#inputs(): SessionInput[] {
@@ -433,6 +516,7 @@ export class LocalSession {
 					await connection.send({ type: "delivery", delivery });
 					await completion.promise;
 					this.#deliveries.delete(delivery.id);
+					this.#notify(`Result saved for ChatGPT ${delivery.chatId.slice(-4)}`);
 				} finally {
 					this.#stores.delete(delivery.id);
 				}

package/src/state.ts

@@ -1,17 +1,22 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { DeliveryRecord } from "./delivery.ts";
+import type { QuestionAnswer, QuestionRecord } from "./questions.ts";
 
 interface StateFile {
 	bindings?: Record<string, string>;
+	workflows?: Record<string, string>;
 	deliveries?: DeliveryRecord[];
+	questions?: QuestionRecord[];
 }
 
 export class State {
 	readonly #path: string;
 	readonly #temporaryPath: string;
 	readonly #bindings = new Map<string, string>();
+	readonly #workflows = new Map<string, string>();
 	readonly #deliveries = new Map<string, DeliveryRecord>();
+	readonly #questions = new Map<string, QuestionRecord>();
 	#writes = Promise.resolve();
 
 	constructor(agentDir: string) {
@@ -31,15 +36,35 @@ export class State {
 		for (const [chatId, sessionId] of Object.entries(state.bindings ?? {})) {
 			if (typeof sessionId === "string") this.#bindings.set(chatId, sessionId);
 		}
+		for (const [chatId, id] of Object.entries(state.workflows ?? {})) {
+			this.#workflows.set(chatId, id);
+		}
 		for (const delivery of state.deliveries ?? []) {
 			if (delivery?.id) this.#deliveries.set(delivery.id, delivery);
 		}
+		for (const question of state.questions ?? [])
+			this.#questions.set(question.id, question);
+	}
+
+	workflow(chatId: string): string | undefined {
+		return this.#workflows.get(chatId);
+	}
+
+	setWorkflow(chatId: string, id: string): Promise<void> {
+		this.#workflows.set(chatId, id);
+		return this.#save();
 	}
 
 	binding(chatId: string): string | undefined {
 		return this.#bindings.get(chatId);
 	}
 
+	chats(sessionId: string): string[] {
+		return [...this.#bindings]
+			.filter(([, target]) => target === sessionId)
+			.map(([chatId]) => chatId);
+	}
+
 	bindingCounts(): Map<string, number> {
 		const counts = new Map<string, number>();
 		for (const sessionId of this.#bindings.values()) {
@@ -64,23 +89,89 @@ export class State {
 		return this.#save();
 	}
 
-	removeDeliveries(ids: string[]): Promise<void> {
-		for (const id of ids) this.#deliveries.delete(id);
-		return this.#save();
+	question(chatId: string, id: string): QuestionRecord {
+		const question = this.#questions.get(id);
+		if (!question || question.chatId !== chatId)
+			throw new Error("Question not found in this ChatGPT conversation");
+		return question;
 	}
 
-	async restoreDeliveries(deliveries: DeliveryRecord[]): Promise<void> {
-		for (const delivery of deliveries)
-			this.#deliveries.set(delivery.id, delivery);
+	async addQuestion(question: QuestionRecord): Promise<void> {
+		this.#questions.set(question.id, question);
 		await this.#save();
 	}
 
+	async answer(
+		chatId: string,
+		id: string,
+		answer: QuestionAnswer,
+	): Promise<QuestionRecord> {
+		const question = this.question(chatId, id);
+		const selections = [...new Set(answer.selections)].sort((a, b) => a - b);
+		if (selections.some((index) => !question.options[index]))
+			throw new Error("Unknown question option");
+		if (!question.allowMultiple && selections.length > 1)
+			throw new Error("Select one option");
+		if (answer.skipped && (selections.length > 0 || answer.text))
+			throw new Error("A skipped question cannot include an answer");
+		if (!answer.skipped && selections.length === 0 && !answer.text)
+			throw new Error("Select an option or enter an answer");
+		const value: QuestionAnswer = {
+			selections,
+			text: answer.text,
+			...(answer.skipped ? { skipped: true } : {}),
+		};
+		if (JSON.stringify(question.answer) === JSON.stringify(value))
+			return question;
+		const updated = { ...question, answer: value, delivered: false };
+		await this.addQuestion(updated);
+		return updated;
+	}
+
+	answers(chatId: string): QuestionRecord[] {
+		return [...this.#questions.values()].filter(
+			(question) =>
+				question.chatId === chatId && question.answer && !question.delivered,
+		);
+	}
+
+	async acknowledge(
+		deliveries: DeliveryRecord[],
+		answers: QuestionRecord[],
+		signal: AbortSignal,
+	): Promise<void> {
+		if (deliveries.length === 0 && answers.length === 0) return;
+		signal.throwIfAborted();
+		const delivered = new Map(
+			answers.map((question) => [question, { ...question, delivered: true }]),
+		);
+		for (const delivery of deliveries) this.#deliveries.delete(delivery.id);
+		for (const [question, updated] of delivered) {
+			if (this.#questions.get(question.id) === question)
+				this.#questions.set(question.id, updated);
+		}
+		try {
+			await this.#save();
+			signal.throwIfAborted();
+		} catch (error) {
+			for (const delivery of deliveries)
+				this.#deliveries.set(delivery.id, delivery);
+			for (const [question, updated] of delivered) {
+				if (this.#questions.get(question.id) === updated)
+					this.#questions.set(question.id, question);
+			}
+			await this.#save();
+			throw error;
+		}
+	}
+
 	#save(): Promise<void> {
 		const saved = this.#writes.then(async () => {
 			const bindings = Object.fromEntries(this.#bindings);
+			const workflows = Object.fromEntries(this.#workflows);
 			await writeFile(
 				this.#temporaryPath,
-				`${JSON.stringify({ bindings, deliveries: [...this.#deliveries.values()] }, null, 2)}\n`,
+				`${JSON.stringify({ bindings, workflows, deliveries: [...this.#deliveries.values()], questions: [...this.#questions.values()] }, null, 2)}\n`,
 				{
 					mode: 0o600,
 				},

package/src/stdio.ts

@@ -1,4 +1,4 @@
-import { createWriteStream } from "node:fs";
+import { Writable } from "node:stream";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import {
 	StdioServerTransport,
@@ -15,7 +15,15 @@ const terminationSignals =
 export async function serveChappie(): Promise<never> {
 	const broker = new Broker(getAgentDir());
 	await broker.start();
-	const output = createWriteStream("", { fd: 1, autoClose: false });
+	const output = new Writable({
+		write(chunk, encoding, callback) {
+			Reflect.apply(Writable.prototype.write, process.stdout, [
+				chunk,
+				encoding,
+				callback,
+			]);
+		},
+	});
 	const transport = new StdioServerTransport(process.stdin, output);
 	let stop: (() => void) | undefined;
 	const stopped = new Promise<void>((resolve) => {
@@ -23,6 +31,7 @@ export async function serveChappie(): Promise<never> {
 	});
 	const requestStop = (): void => stop?.();
 
+	output.once("error", requestStop);
 	process.stdin.once("end", requestStop);
 	process.stdin.once("close", requestStop);
 	for (const signal of terminationSignals) {

package/src/tools.ts

@@ -6,11 +6,9 @@ import {
 	createWriteToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { fromJsonSchema } from "@modelcontextprotocol/server";
+import { toolResultsContent } from "./delivery.ts";
 import type { SessionInput } from "./ipc.ts";
-import {
-	contentWithImageReferences,
-	resourceDescriptors,
-} from "./resources.ts";
+import { contentWithImageReferences } from "./resources.ts";
 import { transfer } from "./transfer.ts";
 
 export interface ToolInput {
@@ -44,24 +42,7 @@ export function toolResult(
 	return {
 		content: [
 			{ type: "text" as const, text: JSON.stringify({ sessionId, cwd }) },
-			...toolResults.flatMap((result) => [
-				{
-					type: "text" as const,
-					text: JSON.stringify({
-						toolCallId: result.toolCallId,
-						toolName: result.toolName,
-						isError: result.isError,
-					}),
-				},
-				...contentWithImageReferences(sessionId, result.content),
-				...resourceDescriptors(result.details).map((resource) => ({
-					type: "resource_link" as const,
-					uri: resource.uri,
-					name: resource.name,
-					mimeType: resource.mimeType,
-					size: resource.size,
-				})),
-			]),
+			...toolResultsContent(toolResults, sessionId),
 			...inputContent(inputs),
 		],
 		isError: toolResults.some((result) => result.isError),

package/src/transfer.ts

@@ -28,18 +28,18 @@ export const transfer = {
 	name: "transfer",
 	label: "transfer",
 	description:
-		"Copy ChatGPT files into Pi paths, or export Pi paths and Chappie image references as MCP resources. The paths field always names Pi-side sources or destinations.",
+		"Copy ChatGPT files into Pi paths when files is supplied. Otherwise, return resource links for Pi paths or Chappie image references.",
 	parameters: Type.Object({
 		paths: Type.Array(Type.String(), {
 			minItems: 1,
 			description:
-				"Pi paths to import into or export from; chappie:// image references can be exported",
+				"Pi destinations for import; Pi paths or chappie:// image references for export",
 		}),
 		files: Type.Optional(
 			Type.Array(transferFile, {
 				minItems: 1,
 				description:
-					"ChatGPT files matched to paths by index; omit to export Pi paths",
+					"ChatGPT files paired with paths in order; omit for export",
 			}),
 		),
 		overwrite: Type.Optional(