testeiya 0.2.1 → 0.3.9

package/src/bridge.ts

@@ -1,251 +0,0 @@
-/**
- * Transforms Testeiya (Pi SDK) AgentSessionEvent into Vercel AI SDK-compatible JSON messages.
- * Returns null for events that should be skipped.
- */
-export function transformEvent(event: any, messageId: string): Record<string, any> | null {
-  switch (event.type) {
-    case "agent_start":
-      return { type: "start", messageId };
-
-    case "message_update":
-      return transformMessageUpdate(event, messageId);
-
-    case "tool_execution_start":
-      return {
-        type: "tool-input-available",
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        input: event.args,
-      };
-
-    // Live tool progress (bash streams its output tail through this). Each
-    // event carries the full accumulated tail, so the client replaces, never
-    // appends. Sent as a non-standard `tool-output-partial` message.
-    case "tool_execution_update":
-      return {
-        type: "tool-output-partial",
-        toolCallId: event.toolCallId,
-        toolName: event.toolName,
-        output: stringifyResult(event.partialResult),
-      };
-
-    case "tool_execution_end": {
-      if (event.isError) {
-        return {
-          type: "tool-output-available",
-          toolCallId: event.toolCallId,
-          isError: true,
-          output: `Error: ${stringifyResult(event.result)}`,
-        };
-      }
-      // Widget tools return their card payload via `details.widget` (see
-      // webui/tools/widget-result.ts) — the model only sees the ack in
-      // `content`, the UI renders the payload.
-      const widget = event.result?.details?.widget;
-      return {
-        type: "tool-output-available",
-        toolCallId: event.toolCallId,
-        isError: false,
-        output:
-          widget !== undefined
-            ? JSON.stringify(widget)
-            : stringifyResult(event.result),
-      };
-    }
-
-    case "turn_start":
-      return { type: "start-step" };
-
-    case "turn_end":
-      return { type: "finish-step" };
-
-    case "agent_end":
-      return { type: "finish" };
-
-    default:
-      return null;
-  }
-}
-
-function transformMessageUpdate(event: any, messageId: string): Record<string, any> | null {
-  const msg = event.assistantMessageEvent;
-  if (!msg) return null;
-
-  switch (msg.type) {
-    case "text_start":
-      return { type: "text-start", id: messageId };
-
-    case "text_delta":
-      return { type: "text-delta", id: messageId, delta: msg.delta };
-
-    case "text_end":
-      return { type: "text-end", id: messageId };
-
-    case "thinking_start":
-      return { type: "reasoning-start", id: messageId };
-
-    case "thinking_delta":
-      return { type: "reasoning-delta", id: messageId, delta: msg.delta };
-
-    case "thinking_end":
-      return { type: "reasoning-end", id: messageId };
-
-    default:
-      return null;
-  }
-}
-
-/**
- * Convert a persisted SDK conversation transcript (AgentMessage[]) into the UI's
- * ChatMessage[] shape so a resumed conversation renders the same as a live one.
- */
-export function historyToChatMessages(messages: any[]): ChatMessage[] {
-  const out: ChatMessage[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg?.role === "user") {
-      const content = stripInjectedContext(textOf(msg.content));
-      if (content) out.push({ id: `hist_${i}`, role: "user", content });
-      continue;
-    }
-    if (msg?.role === "assistant") {
-      out.push(assistantToChatMessage(msg, i));
-      continue;
-    }
-    if (msg?.role === "toolResult") {
-      attachToolResult(out, msg);
-    }
-  }
-  return out;
-}
-
-function assistantToChatMessage(msg: any, index: number): ChatMessage {
-  const parts = Array.isArray(msg.content) ? msg.content : [];
-  const text = parts
-    .filter((p: any) => p?.type === "text")
-    .map((p: any) => p.text ?? "")
-    .join("");
-  const thinking = parts
-    .filter((p: any) => p?.type === "thinking")
-    .map((p: any) => p.thinking ?? p.text ?? "")
-    .join("");
-  const tools: ToolCall[] = parts
-    .filter((p: any) => p?.type === "toolCall")
-    .map((p: any) => ({
-      toolCallId: p.id,
-      toolName: p.name,
-      input: p.arguments ?? {},
-      state: "input-available",
-    }));
-  // Preserve the true thinking↔text↔tool ordering from the transcript so a
-  // resumed turn renders like a live one — reasoning inline where it happened,
-  // not merged into one block; consecutive thinking parts grouped.
-  const orderedParts: MessagePart[] = [];
-  for (const p of parts) {
-    if (p?.type === "thinking") {
-      const content = p.thinking ?? p.text ?? "";
-      if (!content) continue;
-      const last = orderedParts[orderedParts.length - 1];
-      if (last?.type === "reasoning") {
-        last.content = `${last.content}\n\n${content}`;
-        continue;
-      }
-      orderedParts.push({ type: "reasoning", content, isStreaming: false });
-    }
-    if (p?.type === "text" && (p.text ?? "")) orderedParts.push({ type: "text", text: p.text });
-    if (p?.type === "toolCall") orderedParts.push({ type: "tool", toolCallId: p.id });
-  }
-
-  const message: ChatMessage = { id: `hist_${index}`, role: "assistant", content: text };
-  if (thinking) message.reasoning = { content: thinking, isStreaming: false };
-  if (tools.length > 0) message.tools = tools;
-  if (orderedParts.length > 0) message.parts = orderedParts;
-  return message;
-}
-
-function attachToolResult(out: ChatMessage[], msg: any): void {
-  for (let i = out.length - 1; i >= 0; i--) {
-    const tool = out[i].tools?.find((t) => t.toolCallId === msg.toolCallId);
-    if (!tool) continue;
-    const widget = msg.details?.widget;
-    if (widget !== undefined && !msg.isError) {
-      tool.output = JSON.stringify(widget);
-    } else {
-      tool.output = stringifyResult(msg.content);
-    }
-    tool.state = msg.isError ? "output-error" : "output-available";
-    return;
-  }
-}
-
-/**
- * Strip server-injected context blocks that are appended to a prompt — e.g.
- * `<browser_state>…</browser_state>` (and any future `<tag …>…</tag>` we add) —
- * so they never leak into a conversation title or a replayed user bubble.
- * Removes both leading (legacy prepended sessions) and trailing (current
- * appended) runs of paired-tag blocks. The trailing match is generic, so a user
- * message that legitimately ends with its own paired XML/markup tag will lose
- * that trailing tag here — the same tradeoff the leading match already accepts.
- */
-export function stripInjectedContext(text: string): string {
-  return text
-    .replace(/^(?:\s*<([a-zA-Z][\w-]*)\b[^>]*>[\s\S]*?<\/\1>\s*)+/, "")
-    .replace(/(?:\s*<([a-zA-Z][\w-]*)\b[^>]*>[\s\S]*?<\/\1>\s*)+$/, "")
-    .trim();
-}
-
-function textOf(content: any): string {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter((p: any) => p?.type === "text")
-    .map((p: any) => p.text ?? "")
-    .join("");
-}
-
-function stringifyResult(result: any): string {
-  if (result === undefined || result === null) return "";
-  if (typeof result === "string") return result;
-  if (Array.isArray(result)) {
-    return result
-      .filter((item: any) => !isUiNotice(item))
-      .map((item: any) => {
-        if (typeof item === "string") return item;
-        if (item?.type === "text") return item.text;
-        return JSON.stringify(item);
-      })
-      .join("\n");
-  }
-  if (Array.isArray(result?.content)) return stringifyResult(result.content);
-  return JSON.stringify(result);
-}
-
-// The webui extension appends a model-facing "[UI notice …]" text item to MCP
-// list results; forwarding it corrupts the JSON the client parses for the
-// expanded tool card's table.
-function isUiNotice(item: any): boolean {
-  if (item?.type !== "text" || typeof item.text !== "string") return false;
-  return item.text.trimStart().startsWith("[UI notice");
-}
-
-interface ToolCall {
-  toolCallId: string;
-  toolName: string;
-  input: Record<string, unknown>;
-  output?: string;
-  state: "input-available" | "output-available" | "output-error";
-}
-
-type MessagePart =
-  | { type: "text"; text: string }
-  | { type: "tool"; toolCallId: string }
-  | { type: "reasoning"; content: string; isStreaming: boolean; duration?: number };
-
-interface ChatMessage {
-  id: string;
-  role: "user" | "assistant";
-  content: string;
-  parts?: MessagePart[];
-  reasoning?: { content: string; isStreaming: boolean; duration?: number };
-  tools?: ToolCall[];
-}

package/src/check-tests.ts

@@ -1,156 +0,0 @@
-// One place to run the `check-tests` CLI for manual-test sync (pull & push).
-//
-// Used by the initial project pull (agent-start) and the in-app Sync button
-// (api/workspace-sync). We resolve the LOCAL `check-tests` bin we already ship
-// as a dependency and run it with the current runtime — this avoids the slow
-// `npx check-tests@latest` registry download (which can take 30s+ on a cold
-// cache and made the first project pull appear to hang). `npx` stays as a
-// fallback only when the local bin can't be resolved.
-
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import fs from "node:fs";
-import path from "node:path";
-import { writeSyncSnapshot } from "./sync-snapshot.js";
-import { publishCheckTests } from "./debug-bus.js";
-
-const require = createRequire(import.meta.url);
-const RUN_TIMEOUT_MS = 120_000;
-
-let cachedBin: string | null | undefined;
-
-/** Run `check-tests <pull|push> -d <dir>` in `cwd` with the project token. */
-export async function runCheckTests(
-  action: CheckTestsAction,
-  opts: RunCheckTestsOptions
-): Promise<RunCheckTestsResult> {
-  const dir = opts.dir || ".";
-  const env: Record<string, string> = { ...process.env, TESTOMATIO: opts.token };
-  if (opts.baseUrl) env.TESTOMATIO_URL = opts.baseUrl;
-
-  const bin = resolveCheckTestsBin();
-  let command = "npx";
-  let args = ["-y", "check-tests@latest", action, "-d", dir];
-  if (bin) {
-    command = process.execPath;
-    args = [bin, action, "-d", dir];
-  }
-  if (action === "pull") {
-    args.push("--force");
-    if (opts.exportAutomated) args.push("--export-automated");
-    if (opts.suiteIds?.length) args.push("--suite-ids", opts.suiteIds.join(","));
-  }
-  if (action === "push" && opts.files?.length) {
-    args.push("-f", ...toDirRelative(opts.files, dir));
-  }
-
-  console.log(
-    `[check-tests] ${action} -d ${dir} (cwd ${opts.cwd})${bin ? " [local bin]" : " [npx]"}`
-  );
-
-  const started = Date.now();
-  return new Promise<RunCheckTestsResult>((resolve) => {
-    const child = spawn(command, args, { cwd: opts.cwd, env });
-    let output = "";
-    const onData = (chunk: Buffer) => {
-      output += chunk.toString();
-    };
-    child.stdout.on("data", onData);
-    child.stderr.on("data", onData);
-
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      output += `\n[check-tests] timed out after ${RUN_TIMEOUT_MS}ms`;
-    }, RUN_TIMEOUT_MS);
-
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      const out = `${output}\n${err.message}`.trim();
-      publishCheckTests({ action, dir, code: null, output: out, durationMs: Date.now() - started });
-      resolve({ ok: false, action, dir, output: out });
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      console.log(`[check-tests] ${action} exited ${code}`);
-      publishCheckTests({
-        action,
-        dir,
-        code,
-        output: output.trim(),
-        durationMs: Date.now() - started,
-      });
-      if (code === 0) snapshotAfterSync(opts.cwd, dir, opts.files);
-      resolve({ ok: code === 0, action, dir, output: output.trim() });
-    });
-  });
-}
-
-/** Resolve the shipped `check-tests` CLI entry, cached after the first lookup. */
-function resolveCheckTestsBin(): string | null {
-  if (cachedBin !== undefined) return cachedBin;
-  const candidates: string[] = [];
-  try {
-    candidates.push(require.resolve("check-tests/package.json"));
-  } catch {
-    /* not resolvable from here — try cwd below */
-  }
-  candidates.push(path.join(process.cwd(), "node_modules/check-tests/package.json"));
-  for (const pkgPath of candidates) {
-    try {
-      if (!fs.existsSync(pkgPath)) continue;
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-      let binRel = pkg.bin;
-      if (binRel && typeof binRel === "object") {
-        binRel = binRel["check-tests"] ?? Object.values(binRel)[0];
-      }
-      if (!binRel || typeof binRel !== "string") continue;
-      cachedBin = path.resolve(path.dirname(pkgPath), binRel);
-      return cachedBin;
-    } catch {
-      continue;
-    }
-  }
-  cachedBin = null;
-  return null;
-}
-
-/** Refresh the change-tracking baseline; never let a snapshot error break sync. */
-function snapshotAfterSync(cwd: string, dir: string, onlyFiles?: string[]): void {
-  try {
-    writeSyncSnapshot(cwd, dir, onlyFiles);
-  } catch (err) {
-    console.error(
-      `[check-tests] snapshot failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-
-/** Re-base cwd-relative paths onto the `-d` dir for `check-tests push -f`. */
-function toDirRelative(files: string[], dir: string): string[] {
-  const base = dir === "." ? "" : dir;
-  if (!base) return files;
-  return files.map((f) => (f.startsWith(`${base}/`) ? f.slice(base.length + 1) : f));
-}
-
-export type CheckTestsAction = "pull" | "push";
-
-export interface RunCheckTestsOptions {
-  cwd: string;
-  dir: string;
-  token: string;
-  baseUrl?: string;
-  // push: only these files (cwd-relative) via `-f`; also scopes the snapshot.
-  // pull: scopes the snapshot re-baseline to these files (a single-suite pull).
-  files?: string[];
-  // pull: `--suite-ids` (e.g. `@S12345678`) to fetch only specific suites.
-  suiteIds?: string[];
-  // pull: include automated tests in the exported markdown (`--export-automated`).
-  exportAutomated?: boolean;
-}
-
-export interface RunCheckTestsResult {
-  ok: boolean;
-  action: CheckTestsAction;
-  dir: string;
-  output: string;
-}

package/src/cli.ts

@@ -1,17 +0,0 @@
-#!/usr/bin/env bun
-process.title = "testeiya";
-
-// Fix: OSC 133 shell integration sequences cause TUI width overflow crash.
-// The SDK's UserMessageComponent appends OSC 133 sequences that visibleWidth()
-// counts as visible chars, exceeding terminal width. Patch the prototype to skip them.
-import { UserMessageComponent } from "@oh-my-pi/pi-coding-agent/modes/components/user-message";
-import { Container } from "@oh-my-pi/pi-tui";
-UserMessageComponent.prototype.render = function (width: number): string[] {
-  return Container.prototype.render.call(this, width);
-};
-
-import { main } from "./main.js";
-main(process.argv.slice(2)).catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/src/commands.ts

@@ -1,244 +0,0 @@
-// Slash-command extension for Testeiya.
-//
-// All in-session commands register through the SDK's
-// `pi.registerCommand(name, { description, handler })` surface. Handlers get an
-// ExtensionCommandContext with proper UI primitives (ctx.ui.select / notify /
-// input / confirm), so we never have to inspect raw input shapes or fight the
-// TUI by writing to stdout.
-//
-// Add new commands by writing a `register<Name>Command(pi)` function below and
-// calling it from `createCommandsExtension()`.
-
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import type { ExtensionFactory } from "@oh-my-pi/pi-coding-agent";
-
-import {
-  fetchProjects,
-  loadStoredAuth,
-  saveStoredAuth,
-  normalizeBaseUrl,
-  UnauthorizedError,
-  type Project,
-  type StoredAuth,
-} from "./testomatio-auth.js";
-import { buildTestomatioMcpServers } from "./api/agent-start.js";
-import { testomatioTms, testomatioConnection } from "./prompt/testomatio.js";
-import { PROJECT_DIR } from "./project-dir.js";
-import { readJson } from "./json-store.js";
-
-export function createCommandsExtension(runtime: CommandsRuntime): ExtensionFactory {
-  return ((pi: any) => {
-    registerConnectCommand(pi, runtime);
-    registerProjectCommand(pi, runtime);
-    // A connection made mid-session postdates the base system prompt, which was
-    // built without Testomat.io context — layer it onto every following turn.
-    pi.on("before_agent_start", (event: any) => {
-      if (!runtime.connection) return;
-      const { projectId, backendUrl } = runtime.connection;
-      return {
-        systemPrompt: [
-          event.systemPrompt,
-          testomatioTms,
-          testomatioConnection([projectId], backendUrl),
-        ].join("\n\n"),
-      };
-    });
-  }) as ExtensionFactory;
-}
-
-function registerConnectCommand(pi: any, runtime: CommandsRuntime): void {
-  pi.registerCommand("connect", {
-    description: "Connect a Testomat.io project and load its MCP tools",
-    async handler(_args: string, ctx: any): Promise<void> {
-      let stored = loadStoredAuth();
-      if (!stored) {
-        const baseUrl = normalizeBaseUrl();
-        const token = await promptForToken(ctx, baseUrl);
-        if (!token) return;
-        stored = { token, baseUrl };
-        saveStoredAuth(stored);
-      }
-
-      const auth = await fetchProjectsWithReauth(stored, ctx);
-      if (!auth) return;
-      if (auth.projects.length === 0) {
-        ctx.ui.notify("No Testomat.io projects available for this account.", "warning");
-        return;
-      }
-
-      const chosen = await selectProject(auth.projects, "Select a Testomat.io project", ctx);
-      if (!chosen) return;
-
-      await applyProject(chosen, auth.stored, runtime, ctx);
-    },
-  });
-}
-
-function registerProjectCommand(pi: any, runtime: CommandsRuntime): void {
-  pi.registerCommand("project", {
-    description: "Switch the active Testomat.io project",
-    async handler(_args: string, ctx: any): Promise<void> {
-      const stored = loadStoredAuth();
-      if (!stored?.token) {
-        ctx.ui.notify("No stored Testomat.io credentials. Run /connect first.", "error");
-        return;
-      }
-
-      const auth = await fetchProjectsWithReauth(stored, ctx);
-      if (!auth) return;
-      if (auth.projects.length === 0) {
-        ctx.ui.notify("No Testomat.io projects available for this account.", "warning");
-        return;
-      }
-
-      const chosen = await selectProject(auth.projects, "Switch Testomat.io project", ctx);
-      if (!chosen) return;
-
-      const activeId = runtime.connection?.projectId ?? process.env.TESTOMATIO_PROJECT_ID;
-      if (chosen.id === activeId) {
-        ctx.ui.notify(`Already on ${chosen.title} (${chosen.id}).`, "info");
-        return;
-      }
-
-      await applyProject(chosen, auth.stored, runtime, ctx);
-    },
-  });
-}
-
-async function promptForToken(ctx: any, baseUrl: string): Promise<string | null> {
-  ctx.ui.notify(
-    `Open ${baseUrl}/users/sign_in?auth=jwt — sign in, click Authorize, copy the token.`,
-    "info",
-  );
-  const answer = await ctx.ui.input("Paste the Testomat.io token", "eyJ…");
-  const token = answer?.trim();
-  if (!token) return null;
-  if (!token.startsWith("eyJ")) {
-    ctx.ui.notify("That doesn't look like a token (expected to start with 'eyJ').", "error");
-    return null;
-  }
-  return token;
-}
-
-async function fetchProjectsWithReauth(
-  stored: StoredAuth,
-  ctx: any,
-): Promise<{ stored: StoredAuth; projects: Project[] } | null> {
-  let current = stored;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const projects = await fetchProjects(current.token, current.baseUrl);
-      return { stored: current, projects };
-    } catch (err) {
-      if (!(err instanceof UnauthorizedError) || attempt > 0) {
-        ctx.ui.notify(
-          `Failed to fetch projects: ${err instanceof Error ? err.message : String(err)}`,
-          "error",
-        );
-        return null;
-      }
-      ctx.ui.notify("Stored Testomat.io token was rejected — re-authorize.", "warning");
-      const token = await promptForToken(ctx, current.baseUrl);
-      if (!token) return null;
-      current = { ...current, token };
-      saveStoredAuth(current);
-    }
-  }
-  return null;
-}
-
-async function selectProject(
-  projects: Project[],
-  title: string,
-  ctx: any,
-): Promise<Project | null> {
-  if (projects.length === 1) return projects[0]!;
-  const labels = projects.map(formatProjectLabel);
-  const picked = await ctx.ui.select(title, labels);
-  if (!picked) return null;
-  const idx = labels.indexOf(picked);
-  if (idx < 0) return null;
-  return projects[idx]!;
-}
-
-async function applyProject(
-  project: Project,
-  stored: StoredAuth,
-  runtime: CommandsRuntime,
-  ctx: any,
-): Promise<void> {
-  saveStoredAuth({ ...stored, projectId: project.id });
-  process.env.TESTOMATIO = project.apiKey;
-  process.env.TESTOMATIO_URL = stored.baseUrl;
-  process.env.TESTOMATIO_PROJECT_ID = project.id;
-  runtime.connection = { projectId: project.id, backendUrl: stored.baseUrl };
-
-  const servers = await buildTestomatioMcpServers(
-    [{ slug: project.id, token: project.apiKey }],
-    stored.baseUrl,
-  );
-  writeMcpConfig(runtime.cwd, servers);
-
-  const mcp = runtime.mcpManager;
-  if (!mcp) {
-    ctx.ui.notify(
-      `Connected to ${project.title} (${project.id}). Restart testeiya to load MCP.`,
-      "info",
-    );
-    return;
-  }
-
-  ctx.ui.notify(`Connecting Testomat.io MCP for ${project.title}…`, "info");
-  for (const name of mcp.getAllServerNames?.() ?? []) {
-    if (!name.startsWith("testomatio-")) continue;
-    if (servers[name]) continue;
-    await mcp.disconnectServer(name);
-  }
-  const result = await mcp.discoverAndConnect();
-  const failed = Object.keys(servers).find((name) => result?.errors?.get?.(name));
-  if (failed) {
-    ctx.ui.notify(
-      `Testomat.io MCP failed to connect: ${result.errors.get(failed)}`,
-      "error",
-    );
-    return;
-  }
-  ctx.ui.notify(
-    `Connected to ${project.title} (${project.id}) · ${countTestomatioTools(mcp)} MCP tools loaded.`,
-    "info",
-  );
-}
-
-function writeMcpConfig(cwd: string, servers: Record<string, unknown>): void {
-  const dir = join(cwd, PROJECT_DIR);
-  mkdirSync(dir, { recursive: true });
-  for (const file of ["mcp.json", "mcp.all.json"]) {
-    const filePath = join(dir, file);
-    const existing = readJson<{ mcpServers?: Record<string, unknown> }>(filePath, {});
-    const mcpServers: Record<string, unknown> = {};
-    for (const [name, config] of Object.entries(existing.mcpServers ?? {})) {
-      if (name.startsWith("testomatio-")) continue;
-      mcpServers[name] = config;
-    }
-    Object.assign(mcpServers, servers);
-    writeFileSync(filePath, JSON.stringify({ mcpServers }, null, 2), "utf8");
-  }
-}
-
-function countTestomatioTools(mcp: any): number {
-  const tools = mcp.getTools?.() ?? [];
-  return tools.filter((t: any) => /^testomatio-/.test(t?.mcpServerName ?? t?.name ?? "")).length;
-}
-
-function formatProjectLabel(p: Project): string {
-  const fw = p.framework ? `  ·  ${p.framework}` : "";
-  return `${p.title}  (${p.id})${fw}`;
-}
-
-export interface CommandsRuntime {
-  cwd: string;
-  mcpManager?: any;
-  connection?: { projectId: string; backendUrl: string };
-}