@osolmaz/pi-workflows 0.1.0 → 0.2.0

package/src/extension/session-events.ts

@@ -0,0 +1,119 @@
+export type PublicAssistantMessageEvent =
+  | { type: "start"; partial: unknown }
+  | { type: "text_start"; contentIndex: number; partial: unknown }
+  | { type: "text_delta"; contentIndex: number; delta: string; partial: unknown }
+  | { type: "text_end"; contentIndex: number; content: string; partial: unknown }
+  | { type: "thinking_start"; contentIndex: number; partial: unknown }
+  | { type: "thinking_delta"; contentIndex: number; delta: string; partial: unknown }
+  | { type: "thinking_end"; contentIndex: number; content: string; partial: unknown }
+  | { type: "toolcall_start"; contentIndex: number; partial: unknown }
+  | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: unknown }
+  | { type: "toolcall_end"; contentIndex: number; toolCall: unknown; partial: unknown }
+  | { type: "done"; reason: "stop" | "length" | "toolUse"; message: unknown }
+  | { type: "error"; reason: "aborted" | "error"; error: unknown };
+
+export type TurnStartEventLike = { turnIndex: number };
+export type TurnEndEventLike = { turnIndex: number; message: unknown };
+export type MessageStartEventLike = { message: unknown };
+export type MessageUpdateEventLike = {
+  message: unknown;
+  assistantMessageEvent: PublicAssistantMessageEvent;
+};
+export type MessageEndEventLike = { message: unknown };
+export type ToolExecutionStartEventLike = {
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+};
+export type ToolExecutionUpdateEventLike = { toolCallId: string };
+export type ToolExecutionEndEventLike = {
+  toolCallId: string;
+  toolName: string;
+  result: unknown;
+  isError: boolean;
+};
+
+export type NormalizedAssistantEvent =
+  | { type: "start" }
+  | { type: "text_start"; contentIndex: number }
+  | { type: "text_delta"; contentIndex: number; delta: string }
+  | { type: "text_end"; contentIndex: number; content: string }
+  | { type: "thinking_start"; contentIndex: number }
+  | { type: "thinking_delta"; contentIndex: number; delta: string }
+  | { type: "thinking_end"; contentIndex: number; content: string }
+  | { type: "toolcall_start"; contentIndex: number }
+  | { type: "toolcall_delta"; contentIndex: number; delta: string }
+  | { type: "toolcall_end"; contentIndex: number; toolCall: unknown }
+  | { type: "done"; reason: "stop" | "length" | "toolUse" }
+  | { type: "error"; reason: "aborted" | "error" };
+
+/** Remove cumulative snapshots while preserving every semantic stream event. */
+export function normalizeAssistantEvent(
+  event: PublicAssistantMessageEvent,
+): NormalizedAssistantEvent {
+  switch (event.type) {
+    case "start":
+      return { type: event.type };
+    case "text_start":
+    case "thinking_start":
+    case "toolcall_start":
+      return { type: event.type, contentIndex: event.contentIndex };
+    case "text_delta":
+    case "thinking_delta":
+    case "toolcall_delta":
+      return { type: event.type, contentIndex: event.contentIndex, delta: event.delta };
+    case "text_end":
+    case "thinking_end":
+      return { type: event.type, contentIndex: event.contentIndex, content: event.content };
+    case "toolcall_end":
+      return {
+        type: event.type,
+        contentIndex: event.contentIndex,
+        toolCall: event.toolCall,
+      };
+    case "done":
+      return { type: event.type, reason: event.reason };
+    case "error":
+      return { type: event.type, reason: event.reason };
+    default: {
+      const exhaustive: never = event;
+      return exhaustive;
+    }
+  }
+}
+
+export function messageRole(message: unknown): string {
+  if (typeof message !== "object" || message === null || !("role" in message)) {
+    return "unknown";
+  }
+  const role = (message as { role?: unknown }).role;
+  return typeof role === "string" && role.length > 0 ? role : "unknown";
+}
+
+export function toolCallIdFromAssistantEvent(event: NormalizedAssistantEvent): string | null {
+  if (event.type !== "toolcall_end" || typeof event.toolCall !== "object" || !event.toolCall) {
+    return null;
+  }
+  const id = (event.toolCall as { id?: unknown }).id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+
+export function toolStartedPayload(event: ToolExecutionStartEventLike): Record<string, unknown> {
+  return { toolName: event.toolName, args: event.args };
+}
+
+export function toolFinishedPayload(event: ToolExecutionEndEventLike): Record<string, unknown> {
+  return { toolName: event.toolName, isError: event.isError, result: event.result };
+}
+
+export function turnFinishedPayload(
+  event: TurnEndEventLike,
+  messageId: string | undefined,
+  toolCallIds: string[],
+): Record<string, unknown> {
+  return {
+    turnIndex: event.turnIndex,
+    ...(messageId === undefined ? {} : { messageId }),
+    toolCallIds,
+  };
+}

package/src/extension/widget.ts

@@ -113,16 +113,24 @@ export function buildWidgetLines(
 /** The graph row the window should center on: the active or waiting node. */
 function focusLine(graph: string[], state: WorkflowRunState): number {
   const active = graph.findIndex((line) => stripAnsi(line).includes("◐"));
-  if (active !== -1) {
-    return active;
+  const focus =
+    active !== -1
+      ? active
+      : state.waitingOn
+        ? graph.findIndex((line) => stripAnsi(line).includes(state.waitingOn as string))
+        : -1;
+  if (focus === -1) {
+    return graph.length - 1;
   }
-  if (state.waitingOn) {
-    const waiting = graph.findIndex((line) => stripAnsi(line).includes(state.waitingOn as string));
-    if (waiting !== -1) {
-      return waiting;
-    }
+  let top = focus;
+  while (top > 0 && !/[┌┏]/u.test(stripAnsi(graph[top] ?? ""))) {
+    top -= 1;
   }
-  return graph.length - 1;
+  let bottom = focus;
+  while (bottom + 1 < graph.length && !/[└┗]/u.test(stripAnsi(graph[bottom] ?? ""))) {
+    bottom += 1;
+  }
+  return Math.floor((top + bottom) / 2);
 }
 
 /**
@@ -139,24 +147,18 @@ function windowLines(
   if (lines.length <= budget) {
     return { lines, scroll: 0, maxScroll: 0 };
   }
-  // First pass decides which markers exist; the second re-fits within the
-  // remaining space. A marker flag can only turn on (never off) in the
-  // second pass, so the result stays within budget.
-  let inner = budget;
-  for (let pass = 0; pass < 2; pass += 1) {
-    const start = clampStart(anchor, inner, lines.length, anchorIsStart);
-    inner = budget - (start > 0 ? 1 : 0) - (start + inner < lines.length ? 1 : 0);
-  }
+  // Reserve one combined overflow row, leaving seven rows for a complete
+  // full card even when the widget also has an error footer.
+  const inner = Math.max(1, budget - 1);
   const start = clampStart(anchor, inner, lines.length, anchorIsStart);
   const end = start + inner;
-  const out: string[] = [];
-  if (start > 0) {
-    out.push(ansi.dim(`↑ ${start} more`));
-  }
-  out.push(...lines.slice(start, end));
-  if (end < lines.length) {
-    out.push(ansi.dim(`↓ ${lines.length - end} more · shift+↑/↓ scroll`));
-  }
+  const above = start;
+  const below = Math.max(0, lines.length - end);
+  const out = lines.slice(start, end);
+  const directions = [above > 0 ? `↑ ${above}` : "", below > 0 ? `↓ ${below}` : ""]
+    .filter(Boolean)
+    .join(" · ");
+  out.push(ansi.dim(`${directions} more · shift+↑/↓ scroll`));
   return { lines: out, scroll: start, maxScroll: Math.max(0, lines.length - inner) };
 }
 

package/src/render/canvas.ts

@@ -4,7 +4,20 @@
  * edge polylines join instead of overwriting each other.
  */
 
-export type CanvasStyle = "plain" | "dim" | "taken" | "active" | "back" | "ok" | "fail" | "warn";
+export type CanvasStyle =
+  | "plain"
+  | "dim"
+  | "taken"
+  | "active"
+  | "back"
+  | "ok"
+  | "fail"
+  | "warn"
+  | "branch"
+  | "agent"
+  | "compute"
+  | "action"
+  | "checkpoint";
 
 type CanvasChar = { char: string; style: CanvasStyle };
 
@@ -40,6 +53,11 @@ const STYLE_PRIORITY: CanvasStyle[] = [
   "warn",
   "ok",
   "fail",
+  "branch",
+  "agent",
+  "compute",
+  "action",
+  "checkpoint",
   "taken",
   "active",
 ];