ei-tui 0.6.6 → 0.7.0

package/tui/src/components/MAPScoreOverlay.tsx

@@ -0,0 +1,300 @@
+import { useKeyboard } from "@opentui/solid";
+import { For, createMemo, onMount, onCleanup } from "solid-js";
+import type { RoomMessage, PersonaSummary } from "../../../src/core/types.js";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { useKeyboardNav } from "../context/keyboard.js";
+
+export interface MAPScoreOverlayProps {
+  roomId: string;
+  roomName?: string;
+  messages: RoomMessage[];
+  activeNodeId: string;
+  activeRoomPath: RoomMessage[];
+  personas: PersonaSummary[];
+  judgePersonaId: string;
+  humanName: string;
+  onDismiss: () => void;
+}
+
+interface ScoreRow {
+  round: number | null; // null = initial seed message
+  winnerId: string | null;
+  winnerName: string;
+  winnerScore: number; // total wins for winner at this round
+  messagePreview: string;
+  verdict: string;
+  isInProgress: boolean;
+}
+
+function truncate(s: string, n: number): string {
+  if (s.length <= n) return s;
+  return s.slice(0, n - 1) + "…";
+}
+
+function getMessageText(m: RoomMessage): string {
+  return (m.verbal_response ?? m.content ?? m.silence_reason ?? "").replace(/\n+/g, " ");
+}
+
+export function MAPScoreOverlay(props: MAPScoreOverlayProps) {
+  const { setOverlayActive } = useKeyboardNav();
+  onMount(() => setOverlayActive(true));
+  onCleanup(() => setOverlayActive(false));
+
+  let scrollRef: ScrollBoxRenderable | null = null;
+
+  const personaMap = createMemo(() => {
+    const m = new Map<string, string>();
+    for (const p of props.personas) m.set(p.id, p.display_name);
+    return m;
+  });
+
+  // Active path: walk parent_id chain from active_node_id to root, then reverse.
+  // We can't use getRoomActivePath from state-manager here (TUI component), so we derive it.
+  const activePath = createMemo<RoomMessage[]>(() => {
+    const msgById = new Map<string, RoomMessage>();
+    for (const m of props.messages) msgById.set(m.id, m);
+
+    const chain: RoomMessage[] = [];
+    let cur = msgById.get(props.activeNodeId);
+    while (cur) {
+      chain.push(cur);
+      cur = cur.parent_id ? msgById.get(cur.parent_id) : undefined;
+    }
+    return chain.reverse();
+  });
+
+  const scoreRows = createMemo<ScoreRow[]>(() => {
+    const path = activePath();
+    const pMap = personaMap();
+    const judgeId = props.judgePersonaId;
+
+    if (path.length === 0) return [];
+
+    const msgById = new Map<string, RoomMessage>();
+    for (const m of props.messages) msgById.set(m.id, m);
+
+    // Verdicts are siblings of winners — same parent_id as the winner.
+    // They are NOT on the active path, so index all messages by parent_id.
+    const verdictByParentId = new Map<string, RoomMessage>();
+    for (const m of props.messages) {
+      if (m.persona_id === judgeId && m.silence_reason && m.parent_id) {
+        verdictByParentId.set(m.parent_id, m);
+      }
+    }
+
+    const winCounts = new Map<string, number>();
+    const rows: ScoreRow[] = [];
+    let round = 0;
+
+    const seed = path[0];
+    if (!seed) return rows;
+
+    rows.push({
+      round: null,
+      winnerId: null,
+      winnerName: "—",
+      winnerScore: 0,
+      messagePreview: truncate(getMessageText(seed), 50),
+      verdict: "(initial)",
+      isInProgress: false,
+    });
+
+    // Active path: human → winner-1 → winner-2 → ...
+    // Each non-judge persona message on the path is a round winner.
+    for (const msg of path) {
+      if (msg.role !== "persona" || msg.persona_id === judgeId) continue;
+
+      round++;
+      const winnerId = msg.persona_id ?? "";
+      const prev = winCounts.get(winnerId) ?? 0;
+      const newCount = prev + 1;
+      winCounts.set(winnerId, newCount);
+      const winnerName = pMap.get(winnerId) ?? winnerId.slice(0, 8);
+      const verdictMsg = msg.parent_id ? verdictByParentId.get(msg.parent_id) : undefined;
+      const verdict = verdictMsg ? truncate(verdictMsg.silence_reason ?? "", 50) : "";
+
+      rows.push({
+        round,
+        winnerId,
+        winnerName: `${winnerName} (${newCount})`,
+        winnerScore: newCount,
+        messagePreview: truncate(getMessageText(msg), 50),
+        verdict,
+        isInProgress: false,
+      });
+    }
+
+    return rows;
+  });
+
+  const scoreSummary = createMemo<string>(() => {
+    const path = activePath();
+    const pMap = personaMap();
+    const judgeId = props.judgePersonaId;
+
+    const counts = new Map<string, number>();
+    let humanWins = 0;
+
+    for (const m of path) {
+      if (m.role === "persona" && m.persona_id !== judgeId) {
+        const id = m.persona_id ?? "";
+        counts.set(id, (counts.get(id) ?? 0) + 1);
+      }
+    }
+
+    const completedRounds = scoreRows().filter((r) => !r.isInProgress && r.round !== null).length;
+    if (completedRounds === 0) return "No rounds completed yet.";
+
+    const parts: string[] = [];
+    const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [id, cnt] of sorted) {
+      const name = pMap.get(id) ?? id.slice(0, 8);
+      parts.push(`${name} ${cnt}`);
+    }
+    parts.push(`${props.humanName} ${humanWins}`);
+
+    return "Score: " + parts.join(" — ");
+  });
+
+  useKeyboard((event) => {
+    event.preventDefault();
+    const key = event.name;
+
+    if (key === "q" || key === "escape") {
+      props.onDismiss();
+      return;
+    }
+
+    if (key === "up" || key === "k") {
+      scrollRef?.scrollBy(-1);
+      return;
+    }
+
+    if (key === "down" || key === "j") {
+      scrollRef?.scrollBy(1);
+      return;
+    }
+
+    if (key === "pageup") {
+      if (scrollRef) {
+        scrollRef.scrollBy(-Math.max(1, Math.floor(scrollRef.height / 2)));
+      }
+      return;
+    }
+
+    if (key === "pagedown") {
+      if (scrollRef) {
+        scrollRef.scrollBy(Math.max(1, Math.floor(scrollRef.height / 2)));
+      }
+      return;
+    }
+  });
+
+  const COL_ROUND = 6;
+  const COL_WINNER = 16;
+  const COL_MSG = 36;
+  const COL_VERDICT = 36;
+  const SEP = " │ ";
+
+  const headerLine = createMemo(() => {
+    return (
+      "Round".padEnd(COL_ROUND) +
+      SEP +
+      "Winner".padEnd(COL_WINNER) +
+      SEP +
+      "Message".padEnd(COL_MSG) +
+      SEP +
+      "Verdict"
+    );
+  });
+
+  const dividerLine = createMemo(() => {
+    return (
+      "─".repeat(COL_ROUND) +
+      "─┼─" +
+      "─".repeat(COL_WINNER) +
+      "─┼─" +
+      "─".repeat(COL_MSG) +
+      "─┼─" +
+      "─".repeat(COL_VERDICT)
+    );
+  });
+
+  function formatRow(row: ScoreRow): string {
+    const roundStr =
+      row.round === null ? "  —   " : String(row.round).padStart(3).padEnd(COL_ROUND);
+    const winner = row.winnerName.padEnd(COL_WINNER).slice(0, COL_WINNER);
+    const msg = row.messagePreview.padEnd(COL_MSG).slice(0, COL_MSG);
+    const verdict = row.verdict.padEnd(COL_VERDICT).slice(0, COL_VERDICT);
+    return roundStr + SEP + winner + SEP + msg + SEP + verdict;
+  }
+
+  function rowFg(row: ScoreRow): string {
+    if (row.isInProgress) return "#6272a4";
+    if (row.round === null) return "#586e75";
+    return "#93a1a1";
+  }
+
+  const roomTitle = createMemo(
+    () => `MAP Scoreboard — "${props.roomName ?? props.roomId}"`
+  );
+
+  return (
+    <box
+      position="absolute"
+      width="100%"
+      height="100%"
+      left={0}
+      top={0}
+      backgroundColor="#000000"
+      alignItems="center"
+      justifyContent="center"
+    >
+      <box
+        width="95%"
+        height="95%"
+        backgroundColor="#1a1a2e"
+        borderStyle="single"
+        borderColor="#586e75"
+        flexDirection="column"
+      >
+        <box paddingLeft={1} paddingRight={1} paddingTop={1}>
+          <text fg="#eee8d5">{roomTitle()}</text>
+        </box>
+
+        <box paddingLeft={1} paddingRight={1} marginTop={1} height={1}>
+          <text fg="#6272a4">{headerLine()}</text>
+        </box>
+        <box paddingLeft={1} paddingRight={1} height={1}>
+          <text fg="#44475a">{dividerLine()}</text>
+        </box>
+
+        <scrollbox
+          flexGrow={1}
+          ref={(el: ScrollBoxRenderable) => { scrollRef = el; }}
+        >
+          <For each={scoreRows()}>
+            {(row) => (
+              <box
+                visible={true}
+                paddingLeft={1}
+              >
+                <text fg={rowFg(row)}>{formatRow(row)}</text>
+              </box>
+            )}
+          </For>
+        </scrollbox>
+
+        <box paddingLeft={1} paddingRight={1} height={1}>
+          <text fg="#586e75">{"─".repeat(COL_ROUND + COL_WINNER + COL_MSG + COL_VERDICT + 9)}</text>
+        </box>
+        <box paddingLeft={1} paddingRight={1} height={1}>
+          <text fg="#b58900">{scoreSummary()}</text>
+        </box>
+        <box paddingLeft={1} paddingRight={1} height={1} marginBottom={1}>
+          <text fg="#586e75">{"[q] close  [j/k] scroll  [PgUp/PgDn] page"}</text>
+        </box>
+      </box>
+    </box>
+  );
+}

package/tui/src/components/MessageList.tsx

@@ -1,4 +1,4 @@
-import { For, Show, createMemo, createSignal, createEffect, on } from "solid-js";
+import { For, Show, createMemo, createSignal, createEffect, on, onMount } from "solid-js";
 import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core";
 import { useEi } from "../context/ei.js";
 import { useKeyboardNav } from "../context/keyboard.js";
@@ -40,13 +40,24 @@ export function MessageList() {
   const myId = ++instanceId;
   logger.info(`MessageList instance ${myId} MOUNTED`);
   
-  const { messages, activePersonaId, personas, activeContextBoundary, getQuotes, quotesVersion } = useEi();
+  const { messages, activePersonaId, personas, activeContextBoundary, getQuotes, quotesVersion, getHuman } = useEi();
   const { focusedPanel, registerMessageScroll } = useKeyboardNav();
 
   const isFocused = () => focusedPanel() === "messages";
 
+  const [humanDisplayName, setHumanDisplayName] = createSignal("Human");
   const [allQuotes, setAllQuotes] = createSignal<Quote[]>([]);
 
+  onMount(() => {
+    void getHuman().then(human => {
+      const name =
+        human.settings?.name_display ||
+        human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+        "Human";
+      setHumanDisplayName(name);
+    });
+  });
+
   createEffect(on(() => [messages(), quotesVersion()], () => {
     void getQuotes().then(setAllQuotes);
   }));
@@ -112,7 +123,7 @@ export function MessageList() {
                 const persona = personas().find(p => p.id === activePersonaId());
                 return persona?.display_name ?? "Ei";
               };
-              const speaker = message.role === "human" ? "Human" : getDisplayName();
+              const speaker = message.role === "human" ? humanDisplayName() : getDisplayName();
               const speakerColor = message.role === "human" ? "#2aa198" : "#b58900";
               
               const header = () => `${speaker} (${formatTime(message.timestamp)}) [✂️  ${message._quoteIndex}]:`;

package/tui/src/components/RoomMessageList.tsx

@@ -1,4 +1,4 @@
-import { For, Show, createMemo, createSignal, createEffect, on, onCleanup } from "solid-js";
+import { For, Show, createMemo, createSignal, createEffect, on, onCleanup, onMount } from "solid-js";
 import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core";
 import { useEi } from "../context/ei.js";
 import { useKeyboardNav } from "../context/keyboard.js";
@@ -27,9 +27,21 @@ function formatTime(timestamp: string): string {
 }
 
 export function RoomMessageList() {
-  const { roomMessages, roomActivePath, personas, activeRoomId, getRoom, getQuotes, quotesVersion } = useEi();
+  const { roomMessages, roomActivePath, personas, activeRoomId, getRoom, getQuotes, quotesVersion, getHuman } = useEi();
   const { registerMessageScroll } = useKeyboardNav();
 
+  const [humanDisplayName, setHumanDisplayName] = createSignal("Human");
+
+  onMount(() => {
+    void getHuman().then(human => {
+      const name =
+        human.settings?.name_display ||
+        human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+        "Human";
+      setHumanDisplayName(name);
+    });
+  });
+
   const personaNameMap = createMemo(() => {
     const map = new Map<string, string>();
     for (const p of personas()) {
@@ -99,7 +111,7 @@ export function RoomMessageList() {
   });
 
   const getSpeakerName = (msg: RoomMessage): string => {
-    if (msg.role === "human") return "Human";
+    if (msg.role === "human") return humanDisplayName();
     if (msg.persona_id) return personaNameMap().get(msg.persona_id) ?? msg.persona_id;
     return "Persona";
   };

package/tui/src/context/ei.tsx

@@ -110,6 +110,8 @@ export interface EiContextValue {
   dismissWelcomeOverlay: () => void;
   deleteMessages: (personaId: string, messageIds: string[]) => Promise<void>;
   setMessageContextStatus: (personaId: string, messageId: string, status: ContextStatus) => Promise<void>;
+  deleteRoomMessages: (roomId: string, messageIds: string[]) => Promise<void>;
+  setRoomMessageContextStatus: (roomId: string, messageId: string, status: ContextStatus) => Promise<void>;
   recallPendingMessages: () => Promise<string>;
   getToolProviderList: () => ToolProvider[];
   getToolList: () => ToolDefinition[];
@@ -470,6 +472,22 @@ export const EiProvider: ParentComponent = (props) => {
     setStore("messages", store.messages.map(m => m.id === messageId ? { ...m, context_status: status } : m));
   };
 
+  const deleteRoomMessages = async (roomId: string, messageIds: string[]): Promise<void> => {
+    if (!processor) return;
+    processor.getStateManager().removeRoomMessages(roomId, messageIds);
+    if (roomId === store.activeRoomId) {
+      setStore("roomMessages", msgs => msgs.filter(m => !messageIds.includes(m.id)));
+    }
+  };
+
+  const setRoomMessageContextStatus = async (roomId: string, messageId: string, status: ContextStatus): Promise<void> => {
+    if (!processor) return;
+    processor.getStateManager().updateRoomMessage(roomId, messageId, { context_status: status });
+    if (roomId === store.activeRoomId) {
+      setStore("roomMessages", msgs => msgs.map(m => m.id === messageId ? { ...m, context_status: status } : m));
+    }
+  };
+
   const recallPendingMessages = async (): Promise<string> => {
     if (!processor) return "";
     const personaId = store.activePersonaId;
@@ -905,6 +923,8 @@ export const EiProvider: ParentComponent = (props) => {
     dismissWelcomeOverlay: () => setShowWelcomeOverlay(false),
     deleteMessages,
     setMessageContextStatus,
+    deleteRoomMessages,
+    setRoomMessageContextStatus,
     recallPendingMessages,
     getToolProviderList,
     getToolList,

package/tui/src/util/cyp-tree.ts

@@ -0,0 +1,62 @@
+import type { RoomMessage } from "../../../src/core/types.js";
+
+export interface CYPTreeData {
+  ordered: RoomMessage[];
+  numToId: Map<number, string>;
+  idToNum: Map<string, number>;
+  childrenMap: Map<string, RoomMessage[]>;
+}
+
+export function buildCYPTree(messages: RoomMessage[]): CYPTreeData {
+  const childrenMap = new Map<string, RoomMessage[]>();
+
+  for (const m of messages) {
+    if (m.parent_id !== null && m.parent_id !== undefined) {
+      const existing = childrenMap.get(m.parent_id);
+      if (existing) {
+        existing.push(m);
+      } else {
+        childrenMap.set(m.parent_id, [m]);
+      }
+    }
+  }
+
+  const root = messages.find((m) => m.parent_id === null);
+  const ordered: RoomMessage[] = [];
+  const numToId = new Map<number, string>();
+  const idToNum = new Map<string, number>();
+
+  if (!root) {
+    return { ordered, numToId, idToNum, childrenMap };
+  }
+
+  const queue: RoomMessage[] = [root];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    ordered.push(current);
+    const num = ordered.length;
+    numToId.set(num, current.id);
+    idToNum.set(current.id, num);
+    for (const child of childrenMap.get(current.id) ?? []) {
+      queue.push(child);
+    }
+  }
+
+  return { ordered, numToId, idToNum, childrenMap };
+}
+
+export function getSubtreeIds(
+  rootId: string,
+  childrenMap: Map<string, RoomMessage[]>
+): Set<string> {
+  const result = new Set<string>();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const id = queue.shift()!;
+    result.add(id);
+    for (const child of childrenMap.get(id) ?? []) {
+      queue.push(child.id);
+    }
+  }
+  return result;
+}

package/tui/src/util/yaml-context.ts

@@ -1,5 +1,5 @@
 import YAML from "yaml";
-import type { Message } from "../../../src/core/types.js";
+import type { Message, RoomMessage } from "../../../src/core/types.js";
 import { ContextStatus } from "../../../src/core/types.js";
 
 interface EditableMessage {
@@ -63,4 +63,90 @@ export function contextFromYAML(yamlContent: string): ContextYAMLResult {
   return { messages, deletedMessageIds };
 }
 
+interface FfaEditableNode {
+  id: string;
+  role: "human" | "persona";
+  speaker?: string;
+  context_status: ContextStatus;
+  _delete?: boolean;
+  content?: string;
+  silence_reason?: string;
+  children?: FfaEditableNode[];
+}
+
+function buildNode(msg: RoomMessage, messages: RoomMessage[], speakerMap: Map<string, string>, isRoot = false): FfaEditableNode {
+  const children = messages
+    .filter((m) => m.parent_id === msg.id)
+    .map((child) => buildNode(child, messages, speakerMap));
+
+  const node: FfaEditableNode = {
+    id: msg.id,
+    role: msg.role === "human" ? "human" : "persona",
+    context_status: msg.context_status,
+    ...(!isRoot && { _delete: false }),
+  };
+
+  if (msg.role === "persona" && msg.persona_id) {
+    node.speaker = speakerMap.get(msg.persona_id) ?? msg.persona_id.slice(0, 8);
+  }
+
+  const text = getContent(msg);
+  if (text) node.content = text;
+  if (msg.silence_reason) node.silence_reason = msg.silence_reason;
+  if (children.length > 0) node.children = children;
+
+  return node;
+}
+
+export function ffaContextToYAML(
+  messages: RoomMessage[],
+  speakerMap: Map<string, string>
+): string {
+  const header = [
+    "# context_status: default | always | never",
+    "# _delete: true — removes this message and all its descendants",
+  ].join("\n");
+
+  const rootMsg = messages.find((m) => m.parent_id === null);
+  if (!rootMsg) return header + "\n[]";
 
+  return header + "\n" + YAML.stringify([buildNode(rootMsg, messages, speakerMap, true)], { lineWidth: 0 });
+}
+
+export interface FfaContextYAMLResult {
+  messages: Array<{ id: string; context_status: ContextStatus }>;
+  deletedMessageIds: string[];
+  implicitDeleteCount: number;
+}
+
+export function ffaContextFromYAML(yamlContent: string): FfaContextYAMLResult {
+  const data = YAML.parse(yamlContent) as FfaEditableNode[];
+
+  const deletedMessageIds: string[] = [];
+  const messages: Array<{ id: string; context_status: ContextStatus }> = [];
+  let implicitDeleteCount = 0;
+
+  function collectDeleted(node: FfaEditableNode, parentDeleted: boolean): void {
+    const selfDeleted = parentDeleted || !!node._delete;
+    if (selfDeleted) {
+      deletedMessageIds.push(node.id);
+      if (!node._delete) implicitDeleteCount++;
+    } else {
+      const normalized = (node.context_status ?? 'default').toString().toLowerCase() as ContextStatus;
+      messages.push({ id: node.id, context_status: normalized });
+    }
+    for (const child of node.children ?? []) {
+      collectDeleted(child, selfDeleted);
+    }
+  }
+
+  const nodes = data ?? [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isRoot = i === 0;
+    if (isRoot && node._delete) continue; // root deletion not allowed — it anchors the room
+    collectDeleted(node, false);
+  }
+
+  return { messages, deletedMessageIds, implicitDeleteCount };
+}