pi-one-ui 0.1.1 → 0.2.0

package/extensions/app/runtime/event-coordinator.ts

@@ -0,0 +1,84 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const RUNTIME_EVENTS = [
+  "session_start",
+  "session_shutdown",
+  "agent_start",
+  "agent_end",
+  "agent_settled",
+  "turn_start",
+  "message_update",
+  "message_end",
+  "tool_execution_start",
+  "tool_execution_end",
+  "model_select",
+  "thinking_level_select",
+  "session_info_changed",
+  "session_compact",
+  "session_tree",
+] as const;
+
+export type RuntimeEventName = (typeof RUNTIME_EVENTS)[number];
+export type RuntimeEventHandler = (
+  event: unknown,
+  ctx: ExtensionContext,
+) => void | Promise<void>;
+
+export type EventRegistrar = {
+  on(event: RuntimeEventName, handler: RuntimeEventHandler): void;
+};
+
+/**
+ * Provides the central host event seam used while legacy listeners migrate.
+ */
+export class EventCoordinator {
+  private readonly registrar: EventRegistrar;
+  private readonly handlers = new Map<
+    RuntimeEventName,
+    Set<RuntimeEventHandler>
+  >();
+  private installed = false;
+
+  /**
+   * Creates a coordinator backed by the host event registrar.
+   *
+   * @param registrar Host adapter used to install event listeners.
+   */
+  constructor(registrar: EventRegistrar) {
+    this.registrar = registrar;
+  }
+
+  /**
+   * Registers a handler for one coordinated runtime event.
+   *
+   * @returns A function that removes the handler.
+   */
+  on(event: RuntimeEventName, handler: RuntimeEventHandler): () => void {
+    const handlers = this.handlers.get(event) ?? new Set<RuntimeEventHandler>();
+    handlers.add(handler);
+    this.handlers.set(event, handlers);
+    return () => handlers.delete(handler);
+  }
+
+  /**
+   * Installs one host listener per coordinated event.
+   */
+  install(): void {
+    if (this.installed) return;
+    this.installed = true;
+    for (const event of RUNTIME_EVENTS) {
+      this.registrar.on(event, (payload, ctx) => {
+        let pending: Promise<void> | undefined;
+        for (const handler of this.handlers.get(event) ?? []) {
+          if (pending) {
+            pending = pending.then(() => handler(payload, ctx)).then(() => {});
+            continue;
+          }
+          const result = handler(payload, ctx);
+          if (result instanceof Promise) pending = result.then(() => {});
+        }
+        return pending;
+      });
+    }
+  }
+}

package/extensions/app/runtime/render-scheduler.ts

@@ -0,0 +1,56 @@
+export type RenderRequest = (force: boolean) => void;
+export type RenderSchedule = (run: () => void) => void;
+
+/**
+ * Coalesces render requests emitted by multiple layouts in one turn.
+ */
+export class RenderScheduler {
+  private readonly requestRender: RenderRequest;
+  private readonly schedule: RenderSchedule;
+  private scheduled = false;
+  private forced = false;
+  private disposed = false;
+
+  /**
+   * Creates a scheduler for a concrete render callback.
+   *
+   * @param requestRender Callback that renders the active TUI.
+   * @param schedule Microtask scheduler used to coalesce requests.
+   */
+  constructor(
+    requestRender: RenderRequest,
+    schedule: RenderSchedule = queueMicrotask,
+  ) {
+    this.requestRender = requestRender;
+    this.schedule = schedule;
+  }
+
+  /**
+   * Queues one render and preserves forced redraw priority.
+   *
+   * @param force Whether the pending render must be a full redraw.
+   */
+  request(force = false): void {
+    if (this.disposed) return;
+    this.forced ||= force;
+    if (this.scheduled) return;
+
+    this.scheduled = true;
+    this.schedule(() => {
+      this.scheduled = false;
+      if (this.disposed) return;
+      const forced = this.forced;
+      this.forced = false;
+      this.requestRender(forced);
+    });
+  }
+
+  /**
+   * Cancels future callbacks and makes later requests no-ops.
+   */
+  dispose(): void {
+    this.disposed = true;
+    this.scheduled = false;
+    this.forced = false;
+  }
+}

package/extensions/app/runtime/runtime-state.ts

@@ -0,0 +1,83 @@
+export type RuntimePhase = "idle" | "active";
+
+export type RuntimeState = Readonly<{
+  phase: RuntimePhase;
+  generation: number;
+  mode?: string;
+}>;
+
+export type RuntimeStateListener = (state: RuntimeState) => void;
+
+/**
+ * Stores session-level runtime state while Pi keeps ownership of context data.
+ */
+export class RuntimeStateStore {
+  private currentState: RuntimeState = { phase: "idle", generation: 0 };
+  private readonly listeners = new Set<RuntimeStateListener>();
+
+  /**
+   * Returns the latest immutable runtime state snapshot.
+   */
+  snapshot(): RuntimeState {
+    return this.currentState;
+  }
+
+  /**
+   * Starts a new runtime generation.
+   *
+   * @returns The generation token owned by the new session.
+   */
+  start(mode?: string): number {
+    const generation = this.currentState.generation + 1;
+    this.currentState = { phase: "active", generation, mode };
+    this.notify();
+    return generation;
+  }
+
+  /**
+   * Stops the current generation unless a newer generation is active.
+   *
+   * @param generation Optional token used to reject stale shutdown callbacks.
+   */
+  shutdown(generation?: number): void {
+    if (
+      generation !== undefined &&
+      generation !== this.currentState.generation
+    ) {
+      return;
+    }
+    this.currentState = {
+      phase: "idle",
+      generation: this.currentState.generation,
+    };
+    this.notify();
+  }
+
+  /**
+   * Reports whether a generation token still owns the active runtime.
+   */
+  isCurrent(generation: number): boolean {
+    return (
+      this.currentState.phase === "active" &&
+      this.currentState.generation === generation
+    );
+  }
+
+  /**
+   * Subscribes to runtime state transitions.
+   *
+   * @returns A function that removes the listener.
+   */
+  subscribe(listener: RuntimeStateListener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  /**
+   * Notifies listeners using the current state snapshot.
+   */
+  private notify(): void {
+    const snapshot = this.snapshot();
+    for (const listener of this.listeners) listener(snapshot);
+  }
+}