testeiya 0.2.1 → 0.3.1-0.1

package/src/extensions/webui/tools/render-item.ts

@@ -1,61 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
-import { widgetResult } from "./widget-result.js";
-
-/**
- * `render_item` — display a single Testomat.io entity in detail.
- * Kinds: test, suite, run, testrun, plan. Server-side a no-op;
- * the UI dispatches to per-kind detail cards.
- */
-export const renderItemTool: ToolDefinition = {
-  name: "render_item",
-  label: "Render Item",
-  description:
-    "Display one Testomat.io entity (a single test, suite, run, testrun, " +
-    "or plan) as a detail card. Use when the user asked about one thing " +
-    "specifically, or when you want to highlight a single record. " +
-    "For multiple items use `render_list` instead.",
-  parameters: Type.Object({
-    kind: Type.Union(
-      [
-        Type.Literal("test"),
-        Type.Literal("suite"),
-        Type.Literal("run"),
-        Type.Literal("testrun"),
-        Type.Literal("plan"),
-      ],
-      { description: "What type of entity is being shown." }
-    ),
-    data: Type.Object(
-      {},
-      {
-        additionalProperties: true,
-        description:
-          "The entity object, usually the full MCP result from a " +
-          "`*_get` call. Pass everything you have; the UI picks the " +
-          "fields it needs.",
-      }
-    ),
-    title: Type.Optional(
-      Type.String({
-        description:
-          "Short card header. Defaults to the entity's title/name if " +
-          "omitted, but prefer to pass an explicit one.",
-      })
-    ),
-    summary: Type.Optional(
-      Type.String({
-        description: "Optional one-liner context shown under the title.",
-      })
-    ),
-  }),
-  async execute(toolCallId, params) {
-    const p = params as { kind: string; title?: string };
-    console.log(`[render_item] kind=${p.kind} title="${p.title ?? "(none)"}"`);
-    return widgetResult(
-      `Rendered a ${p.kind} detail card${p.title ? ` "${p.title}"` : ""} ` +
-        `(widget_id: ${toolCallId} — drivable via ui_widget this turn).`,
-      params
-    );
-  },
-};

package/src/extensions/webui/tools/render-list.ts

@@ -1,170 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import vm from "node:vm";
-import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
-import type { CachedList } from "./render-result.js";
-import { widgetResult } from "./widget-result.js";
-
-/**
- * `render_list` — display a list the agent assembled. Rows come from `data`,
- * or are derived server-side: `from` references cached `*_list`/`*_search`
- * results by call id and `transform` (a pure JS function source, run in a
- * vm sandbox) converts those arrays into the rows to render — so derived
- * lists never require re-emitting rows through the model.
- * For showing one fetched result as-is use `render_result`.
- */
-export function createRenderListTool(cache: Map<string, CachedList>): ToolDefinition {
-  return {
-    name: "render_list",
-    label: "Render List",
-    description:
-      "Display a list as a rich table in the chat UI. Pass rows via `data`, " +
-      "or derive them server-side: `from` = call ids of fetched *_list/*_search " +
-      "results, `transform` = a pure JS function over those arrays returning " +
-      "the rows to render (no need to re-type rows). For one result as-is, " +
-      "use render_result.",
-    parameters: Type.Object({
-      kind: Type.Union(
-        [
-          Type.Literal("runs"),
-          Type.Literal("tests"),
-          Type.Literal("suites"),
-          Type.Literal("plans"),
-          Type.Literal("testruns"),
-        ],
-        { description: "What the rows are." }
-      ),
-      data: Type.Optional(
-        Type.Union(
-          [Type.Array(Type.Any()), Type.Object({}, { additionalProperties: true })],
-          { description: "Explicit rows: `{data:[...], meta}` or a plain array." }
-        )
-      ),
-      from: Type.Optional(
-        Type.Union([Type.String(), Type.Array(Type.String())], {
-          description:
-            "Call id(s) of fetched *_list/*_search results (from their UI " +
-            "notices). Their row arrays become the transform's arguments, in order.",
-        })
-      ),
-      transform: Type.Optional(
-        Type.String({
-          description:
-            "Pure JS function source, e.g. \"(all, passed) => { const ok = new " +
-            "Set(passed.map(t => t.id)); return all.map(t => ({...t, status: " +
-            "ok.has(t.id) ? 'passed' : t.status})); }\". Receives one array per " +
-            "`from` id (or the `data` array) and returns the rows to render. " +
-            "Sandboxed: no imports, no IO, 1s limit.",
-        })
-      ),
-      title: Type.Optional(
-        Type.String({
-          description: "Card header: what this list is and how it was derived.",
-        })
-      ),
-      columns: Type.Optional(
-        Type.Array(Type.String(), {
-          description:
-            "Row fields to show as columns, rendered in exactly this order " +
-            "(e.g. ['title', 'status']). Priority is never a column — it " +
-            "renders as an icon next to the title. Omit for the kind's defaults.",
-        })
-      ),
-      summary: Type.Optional(
-        Type.String({ description: "Optional caption above the table." })
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const p = params as RenderListParams;
-      let inputs: Array<unknown[]>;
-      try {
-        inputs = resolveInputs(p, cache);
-      } catch (err) {
-        return errorText(err);
-      }
-
-      let rows: unknown[];
-      if (p.transform) {
-        try {
-          rows = runTransform(p.transform, inputs);
-        } catch (err) {
-          return errorText(err, "transform failed: ");
-        }
-      } else if (inputs.length === 1) {
-        rows = inputs[0];
-      } else {
-        return errorText(
-          new Error("multiple `from` results need a `transform` to combine them")
-        );
-      }
-
-      const payload: Record<string, unknown> = { ...p };
-      delete payload.transform;
-      delete payload.from;
-      payload.data = { data: rows, meta: metaFor(p, rows) };
-      console.log(
-        `[render_list] kind=${p.kind} count=${rows.length} source=${p.data ? "data" : `from(${p.from})`}`
-      );
-      return widgetResult(
-        `Rendered ${rows.length} ${p.kind} rows as a table.`,
-        payload
-      );
-    },
-  };
-}
-
-function resolveInputs(p: RenderListParams, cache: Map<string, CachedList>): Array<unknown[]> {
-  if (p.data) {
-    const rows = Array.isArray(p.data)
-      ? p.data
-      : (p.data as { data?: unknown[] }).data;
-    if (!Array.isArray(rows)) throw new Error("`data` holds no row array");
-    return [rows];
-  }
-  if (!p.from) throw new Error("pass `data`, or `from` call id(s) of fetched results");
-  const ids = Array.isArray(p.from) ? p.from : [p.from];
-  return ids.map((id) => {
-    const entry = cache.get(id);
-    if (!entry) {
-      const known = [...cache.keys()].slice(-5).join(", ") || "none";
-      throw new Error(`call_id "${id}" is not a cached list result (recent: ${known})`);
-    }
-    return entry.rows;
-  });
-}
-
-function runTransform(src: string, inputs: Array<unknown[]>): unknown[] {
-  const sandbox: { __inputs: Array<unknown[]>; __result?: unknown } = {
-    __inputs: inputs,
-  };
-  vm.runInNewContext(`__result = (${src})(...__inputs)`, sandbox, { timeout: 1000 });
-  const result = sandbox.__result;
-  if (!Array.isArray(result)) {
-    throw new Error("transform must return an array of rows");
-  }
-  return result;
-}
-
-function metaFor(p: RenderListParams, rows: unknown[]): { total: number } {
-  if (p.data && !Array.isArray(p.data)) {
-    const total = (p.data as { meta?: { total?: number } }).meta?.total;
-    if (typeof total === "number") return { total };
-  }
-  return { total: rows.length };
-}
-
-function errorText(err: unknown, prefix = ""): { content: Array<{ type: "text"; text: string }> } {
-  const reason = err instanceof Error ? err.message : String(err);
-  return {
-    content: [{ type: "text", text: `${prefix}${reason}` }],
-  };
-}
-
-interface RenderListParams {
-  kind: string;
-  data?: unknown;
-  from?: string | string[];
-  transform?: string;
-  title?: string;
-  summary?: string;
-  columns?: string[];
-}

package/src/extensions/webui/tools/render-result.ts

@@ -1,85 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
-import { widgetResult } from "./widget-result.js";
-
-/**
- * `render_result` — render one previously fetched MCP `*_list`/`*_search`
- * result, referenced by its tool call id. The webui middleware caches each
- * list result (slimmed) as it passes through; this tool echoes the cached
- * rows to the UI so the agent never re-emits (or truncates) them. Columns
- * and icons (status/state/priority) are handled by the UI renderer.
- */
-export function createRenderResultTool(cache: Map<string, CachedList>): ToolDefinition {
-  return {
-    name: "render_result",
-    label: "Render Result",
-    description:
-      "Show the full result of a previous *_list/*_search call as a rich " +
-      "table in the chat UI, referenced by that call's id (given in the " +
-      "result's UI notice). Renders EVERY row of that result.",
-    parameters: Type.Object({
-      call_id: Type.String({
-        description: "The tool call id of the *_list/*_search result to render.",
-      }),
-      title: Type.Optional(
-        Type.String({
-          description: "Card header: what this list is and how it was filtered.",
-        })
-      ),
-      columns: Type.Optional(
-        Type.Array(Type.String(), {
-          description:
-            "Row fields to show as columns, rendered in exactly this order " +
-            "(e.g. ['suite_title', 'title', 'status']). Priority is never a " +
-            "column — it renders as an icon next to the title. Omit for " +
-            "the kind's defaults.",
-        })
-      ),
-      summary: Type.Optional(
-        Type.String({ description: "Optional caption above the table." })
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const p = params as {
-        call_id: string;
-        title?: string;
-        columns?: string[];
-        summary?: string;
-      };
-      const entry = cache.get(p.call_id);
-      if (!entry) {
-        const known = [...cache.keys()].slice(-5).join(", ") || "none";
-        return {
-          content: [
-            {
-              type: "text",
-              text:
-                `call_id "${p.call_id}" is not a cached list result. Reference a ` +
-                `*_list/*_search call from this conversation (recent: ${known}).`,
-            },
-          ],
-        };
-      }
-      const payload = {
-        kind: entry.kind,
-        data: { data: entry.rows, meta: { total: entry.total } },
-        title: p.title,
-        columns: p.columns,
-        summary: p.summary,
-      };
-      console.log(
-        `[render_result] call=${p.call_id} kind=${entry.kind} rows=${entry.rows.length}`
-      );
-      return widgetResult(
-        `Rendered ${entry.rows.length} ${entry.kind} rows (of ${entry.total} total) as a table.`,
-        payload
-      );
-    },
-  };
-}
-
-export interface CachedList {
-  kind: string;
-  rows: Array<Record<string, unknown>>;
-  total: number;
-}

package/src/extensions/webui/tools/render-tree.ts

@@ -1,71 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
-import { widgetResult } from "./widget-result.js";
-
-/**
- * `render_tree` — visualize a nested hierarchy (suites→suites→tests, or
- * the pulled markdown directory tree). Server-side a no-op; the UI
- * walks `nodes` recursively and renders via AI-Elements FileTree.
- */
-export const renderTreeTool: ToolDefinition = {
-  name: "render_tree",
-  label: "Render Tree",
-  description:
-    "Render a nested suite/test hierarchy (or any folder-and-leaf tree) " +
-    "as an interactive collapsible tree in the chat. Use when showing " +
-    "project structure, the workspace's pulled markdown tree, or the " +
-    "suite hierarchy. Always pass a `title` describing what this tree is.",
-  parameters: Type.Object({
-    title: Type.Optional(
-      Type.String({
-        description:
-          "Short header (e.g. 'Suite tree of codeceptjs').",
-      })
-    ),
-    nodes: Type.Array(
-      Type.Object(
-        {
-          name: Type.String(),
-          kind: Type.Union(
-            [
-              Type.Literal("suite"),
-              Type.Literal("test"),
-              Type.Literal("folder"),
-              Type.Literal("file"),
-            ],
-            { description: "'suite'/'folder' have children; 'test'/'file' are leaves." }
-          ),
-          status: Type.Optional(
-            Type.String({
-              description:
-                "Optional run status for this node (e.g. 'passed', 'failed', " +
-                "'skipped', 'pending'). Renders a colored status mark next to " +
-                "the node — use it to show each test's latest result in place.",
-            })
-          ),
-          id: Type.Optional(Type.String()),
-          path: Type.Optional(Type.String()),
-          children: Type.Optional(Type.Array(Type.Any())),
-        },
-        { additionalProperties: true }
-      ),
-      {
-        description:
-          "Top-level nodes. Each node can nest children recursively. Use " +
-          "'suite' or 'folder' for expandable parents, 'test' or 'file' " +
-          "for leaf nodes.",
-        minItems: 1,
-      }
-    ),
-  }),
-  async execute(_toolCallId, params) {
-    const p = params as { title?: string; nodes: unknown[] };
-    console.log(
-      `[render_tree] "${p.title ?? "(untitled)"}" with ${p.nodes?.length ?? 0} root nodes`
-    );
-    return widgetResult(
-      `Rendered tree "${p.title ?? "(untitled)"}" (${p.nodes?.length ?? 0} root nodes).`,
-      params
-    );
-  },
-};

package/src/extensions/webui/tools/ui-widget.ts

@@ -1,54 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { ToolDefinition } from "@oh-my-pi/pi-coding-agent";
-import type { WidgetCommandChannel } from "../widget-channel.js";
-
-/**
- * `ui_widget` — the single tool for driving the widget the user is currently
- * looking at. The active widget's id and its legal actions/params are given to
- * you in the `<active_widget>` context block on each turn. Calling this runs the
- * SAME action the user's buttons trigger (e.g. paginate, filter, open) — the
- * user sees the widget change — and returns the resulting data so you can read
- * it (e.g. page 2 of a list).
- *
- * Like `ask_question`, `execute` BLOCKS on the connection's channel until the
- * client has run the command and returned its result, so the agent loop is
- * parked rather than emitting filler text.
- */
-export function createUiWidgetTool(channel: WidgetCommandChannel): ToolDefinition {
-  return {
-    name: "ui_widget",
-    label: "Control widget",
-    description:
-      "Drive the widget currently shown to the user (the one described in the " +
-      "<active_widget> context block). Pass that block's `id` as `widget_id`, an " +
-      "`action` from its listed actions, and the `params` for that action. The " +
-      "command runs the same control the user's buttons do — they see it happen — " +
-      "and the resulting widget data is returned to you. Use it to paginate " +
-      "(`{action:'list', params:{page:2}}`), filter, or open an item. Only the " +
-      "active widget is controllable. Actions flagged [destructive] change data; " +
-      "confirm with `ask_question` before calling them.",
-    parameters: Type.Object({
-      widget_id: Type.String({
-        description: "The active widget's id, taken from the <active_widget> block.",
-      }),
-      action: Type.String({
-        description: "One of the action names listed for that widget in <active_widget>.",
-      }),
-      params: Type.Optional(
-        Type.Object(
-          {},
-          {
-            additionalProperties: true,
-            description: "Arguments for the action, per its declared params (e.g. {page:2}).",
-          }
-        )
-      ),
-    }),
-    async execute(toolCallId, params, signal) {
-      const p = params as { widget_id: string; action: string; params?: unknown };
-      console.log(`[ui_widget] ${p.widget_id} → ${p.action}(${JSON.stringify(p.params ?? {})})`);
-      const result = await channel.wait(toolCallId, signal);
-      return { content: [{ type: "text", text: result }] };
-    },
-  };
-}

package/src/extensions/webui/tools/widget-result.ts

@@ -1,13 +0,0 @@
-/**
- * Tool result split for UI-rendering tools: `content` carries a short ack —
- * the only part the model ever sees in context — while `details.widget`
- * carries the full card payload. The WS bridge forwards `details.widget` to
- * the chat UI, so rendered data costs the model ~20 tokens instead of the
- * whole payload echoed back.
- */
-export function widgetResult(ack: string, widget: unknown) {
-  return {
-    content: [{ type: "text" as const, text: ack }],
-    details: { widget },
-  };
-}

package/src/extensions/webui/widget-channel.ts

@@ -1,50 +0,0 @@
-/**
- * Per-connection registry of in-flight `ui_widget` calls.
- *
- * `ui_widget`'s `execute()` blocks on `wait(toolCallId)` while the client runs
- * the command against the live widget (paginate, filter, open, …) and ships the
- * resulting data back. The WebSocket connection calls `respond(toolCallId,
- * result)` when the `widget_result` frame arrives; that resolves the pending
- * promise and the SAME turn continues with the data as the tool result.
- *
- * Mirrors `AskChannel` — the difference is the value is the command's JSON
- * result (a string) rather than a user-picked option.
- */
-const CANCELLED =
-  '{"ok":false,"error":"The widget command was cancelled (the turn was aborted or the widget closed)."}';
-
-export class WidgetCommandChannel {
-  private pending = new Map<string, (value: string) => void>();
-
-  wait(toolCallId: string, signal?: AbortSignal): Promise<string> {
-    const { promise, resolve } = Promise.withResolvers<string>();
-    this.pending.set(toolCallId, resolve);
-    if (!signal) return promise;
-    if (signal.aborted) {
-      this.settle(toolCallId, CANCELLED);
-      return promise;
-    }
-    signal.addEventListener("abort", () => this.settle(toolCallId, CANCELLED), {
-      once: true,
-    });
-    return promise;
-  }
-
-  respond(toolCallId: string, value: string): boolean {
-    return this.settle(toolCallId, value);
-  }
-
-  cancelAll(): void {
-    for (const id of Array.from(this.pending.keys())) {
-      this.settle(id, CANCELLED);
-    }
-  }
-
-  private settle(toolCallId: string, value: string): boolean {
-    const resolve = this.pending.get(toolCallId);
-    if (!resolve) return false;
-    this.pending.delete(toolCallId);
-    resolve(value);
-    return true;
-  }
-}