@h-rig/pi-rig 0.0.6-alpha.8 → 0.0.6-alpha.80

package/dist/src/live-mirror.d.ts

@@ -0,0 +1,46 @@
+import type { MinimalPiApi } from "./index";
+/** What we use of pi-tui's Component contract. */
+export type ComponentLike = {
+    render(width: number): string[];
+};
+type AssistantComponentLike = ComponentLike & {
+    updateContent(message: Record<string, unknown>): void;
+};
+type ToolComponentLike = ComponentLike & {
+    markExecutionStarted(): void;
+    updateArgs(args: unknown): void;
+    setArgsComplete(): void;
+    updateResult(result: {
+        content: Array<Record<string, unknown>>;
+        details?: unknown;
+        isError: boolean;
+    }, isPartial?: boolean): void;
+};
+type PiComponentModule = {
+    AssistantMessageComponent: new (message?: unknown) => AssistantComponentLike;
+    UserMessageComponent: new (text: string) => ComponentLike;
+    ToolExecutionComponent: new (toolName: string, toolCallId: string, args: unknown, options: Record<string, unknown>, toolDefinition: unknown, ui: unknown, cwd: string) => ToolComponentLike;
+};
+export type LiveMirrorModules = {
+    components: PiComponentModule;
+};
+export declare const DRONE_MESSAGE_TYPE = "rig-drone";
+export declare const DRONE_USER_MESSAGE_TYPE = "rig-drone-user";
+export type LiveMirror = {
+    /** Feed one worker `pi.event` frame's inner event into the mirror. */
+    handleWorkerEvent(event: Record<string, unknown>): void;
+    /** The setWidget factory used purely to capture the TUI handle. */
+    captureTui(tui: unknown): ComponentLike;
+};
+/**
+ * Wire the live mirror: registers the message renderers and returns the
+ * event feed. Call once per operator session, before events start flowing.
+ */
+export declare function createLiveMirror(input: {
+    pi: MinimalPiApi;
+    /** Worker workspace path, for tool renderers (diff headers etc.). */
+    workerCwd?: string;
+    /** Test seam: fake Pi modules. Defaults to the real dynamic import. */
+    modules?: LiveMirrorModules;
+}): Promise<LiveMirror>;
+export {};

package/dist/src/live-mirror.js

@@ -0,0 +1,223 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/pi-rig/src/live-mirror.ts
+async function loadPiModules() {
+  const components = await import("@earendil-works/pi-coding-agent");
+  return { components };
+}
+function createRootContainer() {
+  const children = [];
+  return {
+    addChild(child) {
+      children.push(child);
+    },
+    removeChild(child) {
+      const index = children.indexOf(child);
+      if (index >= 0)
+        children.splice(index, 1);
+    },
+    clear() {
+      children.length = 0;
+    },
+    render(width) {
+      return children.flatMap((child) => child.render(width));
+    }
+  };
+}
+var DRONE_MESSAGE_TYPE = "rig-drone";
+var DRONE_USER_MESSAGE_TYPE = "rig-drone-user";
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function messageRole(event) {
+  const message = recordOf(event.message);
+  return message && typeof message.role === "string" ? message.role : null;
+}
+function userMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.flatMap((block) => {
+      const record = recordOf(block);
+      return record && record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+    }).join(`
+`);
+  }
+  return "";
+}
+async function createLiveMirror(input) {
+  const { pi } = input;
+  const modules = input.modules ?? await loadPiModules();
+  const cwd = input.workerCwd ?? process.cwd();
+  const turns = new Map;
+  const toolOwners = new Map;
+  const userComponents = new Map;
+  let streamingTurn = null;
+  let sequence = 0;
+  let tui = null;
+  let renderTimer = null;
+  const requestRender = () => {
+    if (renderTimer)
+      return;
+    renderTimer = setTimeout(() => {
+      renderTimer = null;
+      tui?.requestRender?.();
+    }, 33);
+    renderTimer.unref?.();
+  };
+  pi.registerMessageRenderer?.(DRONE_MESSAGE_TYPE, (message) => {
+    const details = recordOf(recordOf(message)?.details);
+    const key = details && typeof details.key === "string" ? details.key : null;
+    return key ? turns.get(key)?.root : undefined;
+  });
+  pi.registerMessageRenderer?.(DRONE_USER_MESSAGE_TYPE, (message) => {
+    const details = recordOf(recordOf(message)?.details);
+    const key = details && typeof details.key === "string" ? details.key : null;
+    return key ? userComponents.get(key) : undefined;
+  });
+  const ensureToolComponent = (turn, toolCallId, toolName, args) => {
+    const existing = turn.tools.get(toolCallId);
+    if (existing)
+      return existing;
+    const component = new modules.components.ToolExecutionComponent(toolName, toolCallId, args, {}, undefined, tui, cwd);
+    turn.root.addChild(component);
+    turn.tools.set(toolCallId, component);
+    toolOwners.set(toolCallId, turn);
+    return component;
+  };
+  const startAssistantTurn = (message) => {
+    const key = `turn-${++sequence}`;
+    const root = createRootContainer();
+    const assistant = new modules.components.AssistantMessageComponent;
+    root.addChild(assistant);
+    const turn = { root, assistant, tools: new Map };
+    assistant.updateContent(message);
+    turns.set(key, turn);
+    streamingTurn = turn;
+    pi.sendMessage?.({ customType: DRONE_MESSAGE_TYPE, content: "drone turn", display: true, details: { key } }, { triggerTurn: false });
+    requestRender();
+  };
+  const updateAssistantTurn = (message) => {
+    const turn = streamingTurn;
+    if (!turn)
+      return;
+    turn.assistant.updateContent(message);
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const block of content) {
+      const record = recordOf(block);
+      if (!record || record.type !== "toolCall")
+        continue;
+      const id = typeof record.id === "string" ? record.id : null;
+      const name = typeof record.name === "string" ? record.name : "tool";
+      if (!id)
+        continue;
+      const component = ensureToolComponent(turn, id, name, record.arguments);
+      component.updateArgs(record.arguments);
+    }
+    requestRender();
+  };
+  const endAssistantTurn = (message) => {
+    const turn = streamingTurn;
+    if (!turn)
+      return;
+    turn.assistant.updateContent(message);
+    const stopReason = typeof message.stopReason === "string" ? message.stopReason : "stop";
+    if (stopReason === "aborted" || stopReason === "error") {
+      const errorText = typeof message.errorMessage === "string" && message.errorMessage ? message.errorMessage : stopReason === "aborted" ? "Operation aborted" : "Error";
+      for (const component of turn.tools.values()) {
+        component.updateResult({ content: [{ type: "text", text: errorText }], isError: true });
+      }
+    } else {
+      for (const component of turn.tools.values()) {
+        component.setArgsComplete();
+      }
+    }
+    streamingTurn = null;
+    requestRender();
+  };
+  const mirrorUserMessage = (message) => {
+    const text = userMessageText(message).trim();
+    if (!text)
+      return;
+    const key = `user-${++sequence}`;
+    userComponents.set(key, new modules.components.UserMessageComponent(text));
+    pi.sendMessage?.({ customType: DRONE_USER_MESSAGE_TYPE, content: text, display: true, details: { key } }, { triggerTurn: false });
+    requestRender();
+  };
+  return {
+    captureTui(capturedTui) {
+      tui = recordOf(capturedTui);
+      return { render: () => [] };
+    },
+    handleWorkerEvent(event) {
+      const type = typeof event.type === "string" ? event.type : null;
+      switch (type) {
+        case "message_start": {
+          const message = recordOf(event.message);
+          if (!message)
+            return;
+          if (messageRole(event) === "assistant")
+            startAssistantTurn(message);
+          else if (messageRole(event) === "user")
+            mirrorUserMessage(message);
+          return;
+        }
+        case "message_update": {
+          const message = recordOf(event.message);
+          if (message && messageRole(event) === "assistant")
+            updateAssistantTurn(message);
+          return;
+        }
+        case "message_end": {
+          const message = recordOf(event.message);
+          if (message && messageRole(event) === "assistant")
+            endAssistantTurn(message);
+          return;
+        }
+        case "tool_execution_start": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const name = typeof event.toolName === "string" ? event.toolName : "tool";
+          if (!id)
+            return;
+          const turn = toolOwners.get(id) ?? streamingTurn;
+          if (!turn)
+            return;
+          ensureToolComponent(turn, id, name, event.args).markExecutionStarted();
+          requestRender();
+          return;
+        }
+        case "tool_execution_update": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const component = id ? toolOwners.get(id)?.tools.get(id) : undefined;
+          const partial = recordOf(event.partialResult);
+          if (component && partial) {
+            const content = Array.isArray(partial.content) ? partial.content : [];
+            component.updateResult({ ...partial, content, isError: false }, true);
+            requestRender();
+          }
+          return;
+        }
+        case "tool_execution_end": {
+          const id = typeof event.toolCallId === "string" ? event.toolCallId : null;
+          const component = id ? toolOwners.get(id)?.tools.get(id) : undefined;
+          const result = recordOf(event.result);
+          if (component && result) {
+            const content = Array.isArray(result.content) ? result.content : [];
+            component.updateResult({ ...result, content, isError: event.isError === true });
+            requestRender();
+          }
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  };
+}
+export {
+  createLiveMirror,
+  DRONE_USER_MESSAGE_TYPE,
+  DRONE_MESSAGE_TYPE
+};

package/dist/src/tools.d.ts

@@ -0,0 +1,19 @@
+import type { RigBridgeClient, RigExtensionContext } from "./client";
+export type RigToolResult = {
+    readonly content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    readonly details?: Record<string, unknown>;
+};
+export type RigToolDefinition = {
+    readonly name: string;
+    readonly label: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly execute: (toolCallId: string, params: Record<string, unknown>) => Promise<RigToolResult>;
+};
+export declare function createRigTools(input: {
+    readonly context: RigExtensionContext;
+    readonly client: RigBridgeClient;
+}): RigToolDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/pi-rig",
-  "version": "0.0.6-alpha.8",
+  "version": "0.0.6-alpha.80",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -10,15 +10,19 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
     "./client": {
+      "types": "./dist/src/client.d.ts",
       "import": "./dist/src/client.js"
     },
     "./commands": {
+      "types": "./dist/src/commands.d.ts",
       "import": "./dist/src/commands.js"
     },
     "./tools": {
+      "types": "./dist/src/tools.d.ts",
       "import": "./dist/src/tools.js"
     }
   },
@@ -27,13 +31,17 @@
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "pi": {
     "extensions": [
       "./dist/src/index.js"
     ]
   },
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.80"
+  },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-coding-agent": ">=0.79.0",
     "typebox": "*"
   }
 }