one-code-extension 0.4.1 → 0.6.0

package/extensions/lib/prompt-options.ts

@@ -0,0 +1,82 @@
+/**
+ * pi's system-prompt options for a session no `prompt()` has run in yet.
+ *
+ * A turn an extension opens from idle skips `before_agent_start`, the one
+ * event that carries the options (upstream ask #17). After the first typed
+ * prompt the extensions rebuild from what that event saw (system-prompt's
+ * idle-turn.ts). Before it they have nothing, so a background completion that
+ * opens a session's first turn used to go out as a user message, which takes
+ * the prompt path and renders as a user bubble.
+ *
+ * A command handler's context does carry the options
+ * (`getSystemPromptOptions`, the same base object `before_agent_start`
+ * receives). So the command that starts background work announces them here:
+ * system-prompt builds the prompt from them, the skill extension lists its
+ * skills, and the notifier opens the turn with the notification itself as a
+ * custom message, rendered like every later one. Pure: no pi imports.
+ *
+ * The same module carries the fork's system-prompt request (below).
+ */
+
+export const PROMPT_OPTIONS_CHANNEL = "one-code:prompt-options";
+
+/**
+ * Whether a `before_agent_start` event opens a run the user typed. pi 1.2.0
+ * also fires the event for a run an extension opens from idle with
+ * `sendMessage(…, { triggerTurn: true })` (a notification, the Stop hook's
+ * continuation, a scheduled fire), marked `messageType: "custom"` and without
+ * `prompt`. Older pi fires it only for prompts and sends no `messageType`.
+ */
+export function isUserRun<E>(event: E): event is Exclude<E, { messageType: "custom" }> {
+	return (event as { messageType?: unknown } | undefined)?.messageType !== "custom";
+}
+
+/** The payload: pi's base options, and the session cwd they were read in. */
+export interface PromptOptionsAnnouncement {
+	options: unknown;
+	cwd: string;
+}
+
+/**
+ * Emit the options of a command context. A context without
+ * `getSystemPromptOptions` (an event handler's, or an older pi) announces
+ * nothing, and the listeners keep their first-turn fallbacks.
+ */
+export function announcePromptOptions(events: { emit(channel: string, data: unknown): void }, ctx: unknown): void {
+	const context = ctx as { getSystemPromptOptions?: () => unknown; cwd?: string } | undefined;
+	if (typeof context?.getSystemPromptOptions !== "function") return;
+	let options: unknown;
+	try {
+		options = context.getSystemPromptOptions();
+	} catch {
+		return; // A torn-down session: nothing to announce.
+	}
+	if (!options || typeof options !== "object") return;
+	events.emit(PROMPT_OPTIONS_CHANNEL, { options, cwd: context.cwd ?? "" } satisfies PromptOptionsAnnouncement);
+}
+
+/**
+ * The system prompt a fork inherits. `ctx.getSystemPrompt()` is pi's own
+ * prompt whenever One Code's is not installed on pi's run: between turns (pi
+ * drops a run's options when it settles), before the first prompt, and in a
+ * turn opened from idle (installed on the wire only, by context_with_system).
+ * A fork started then ran on pi's stock prompt. The system-prompt extension
+ * answers this request synchronously with the prompt the session's next
+ * request carries; no answer (not loaded, a named agent's own prompt, nothing
+ * to build from) leaves the caller's fallback.
+ */
+export const SYSTEM_PROMPT_REQUEST_CHANNEL = "one-code:system-prompt-request";
+
+export interface SystemPromptRequest {
+	/** The requester's context: cwd and model shape the prompt. */
+	ctx: unknown;
+	/** Set by the listener before it returns. */
+	prompt?: string;
+}
+
+/** Ask for One Code's system prompt; `undefined` when nobody answered. */
+export function requestSystemPrompt(events: { emit(channel: string, data: unknown): void }, ctx: unknown): string | undefined {
+	const request: SystemPromptRequest = { ctx };
+	events.emit(SYSTEM_PROMPT_REQUEST_CHANNEL, request);
+	return typeof request.prompt === "string" ? request.prompt : undefined;
+}

package/extensions/lib/queued-delivery.ts

@@ -0,0 +1,44 @@
+/**
+ * Hold something for a message the user queued mid-turn until pi delivers it.
+ *
+ * Since pi 0.86 the `input` event also fires for a message queued while a turn
+ * runs (`streamingBehavior` set; interactive queue, RPC steer/follow_up). A
+ * one-shot reminder emitted there is taken by whatever the model reads next,
+ * usually the running tool's result, so it lands before the message it is
+ * about, a request or more early for a follow-up. A context message of its
+ * own is no better: pi drains one queued message per request, so it arrives a
+ * request late. Instead the caller holds the payload here, keyed by the typed
+ * text, and releases it from `message_start` when pi delivers the user message
+ * with that text (compare with pi-ai's `contentText(content, "")`, the
+ * comparison pi uses for its own queue). pi awaits `message_start` before the
+ * request that carries the message, so a `last-append` one-shot emitted then
+ * is pinned to that message.
+ *
+ * A queued message pi expands first (a prompt template) never matches, nor
+ * does one an extension replaces, unless its replacement carries the typed
+ * text (the skill extension's `details.input`, which hooks matches). Clear on `agent_settled` so its payload
+ * never rides a later, unrelated prompt, and on `session_start`.
+ *
+ * Pure (no pi imports); each extension keeps its own instance.
+ */
+export class QueuedDelivery<T> {
+	private entries: Array<{ text: string; payload: T }> = [];
+
+	hold(text: string, payload: T): void {
+		this.entries.push({ text, payload });
+	}
+
+	/** The payload held for the delivered message with this text, oldest first; removed once released. */
+	release(text: string): T | undefined {
+		const index = this.entries.findIndex((entry) => entry.text === text);
+		return index === -1 ? undefined : this.entries.splice(index, 1)[0].payload;
+	}
+
+	get isEmpty(): boolean {
+		return this.entries.length === 0;
+	}
+
+	clear(): void {
+		this.entries = [];
+	}
+}