ei-tui 0.4.3 → 0.5.1

package/tui/src/util/room-editor.tsx

@@ -0,0 +1,164 @@
+import { spawnEditor } from "./editor.js";
+import type { CommandContext } from "../commands/registry.js";
+import type { RoomEntity, PersonaSummary } from "../../../src/core/types.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+import { logger } from "./logger.js";
+
+export interface RoomEditorOptions {
+  roomId: string;
+  ctx: CommandContext;
+}
+
+function buildRoomEditYAML(room: RoomEntity, personas: PersonaSummary[]): string {
+  const activePersonas = personas.filter((p) => !p.is_archived);
+  const personaLines = activePersonas
+    .map((p) => `  ${p.display_name}: ${room.persona_ids.includes(p.id) ? "true" : "false"}`)
+    .join("\n");
+
+  const judgePersona = room.judge_persona_id
+    ? personas.find((p) => p.id === room.judge_persona_id)
+    : null;
+  const judgeDisplayName = judgePersona ? judgePersona.display_name : "";
+
+  return `# Room: ${room.display_name} (read-only info)
+# Mode: ${room.mode} (cannot be changed)
+display_name: "${room.display_name}"
+
+# Participants (set true/false to add/remove):
+persona_ids:
+${personaLines}
+
+# judge_persona_id: required for messages_against_persona, use display_name from persona_ids
+judge_persona_id: "${judgeDisplayName}"
+`;
+}
+
+function parseRoomEditYAML(content: string, personas: PersonaSummary[]): Partial<RoomEntity> {
+  const lines = content.split("\n");
+  const updates: Partial<RoomEntity> = {};
+
+  let inPersonaIds = false;
+  const personaMapEntries: Array<{ name: string; enabled: boolean }> = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") {
+      continue;
+    }
+
+    if (inPersonaIds && line.match(/^\s+\S/)) {
+      const colonIdx = trimmed.lastIndexOf(":");
+      if (colonIdx !== -1) {
+        const name = trimmed.slice(0, colonIdx).trim();
+        const val = trimmed.slice(colonIdx + 1).trim().toLowerCase();
+        personaMapEntries.push({ name, enabled: val === "true" });
+      }
+      continue;
+    }
+
+    if (inPersonaIds) {
+      inPersonaIds = false;
+    }
+
+    if (trimmed.startsWith("display_name:")) {
+      const val = trimmed.slice("display_name:".length).trim().replace(/^["']|["']$/g, "");
+      if (val) updates.display_name = val;
+    } else if (trimmed.startsWith("judge_persona_id:")) {
+      const val = trimmed.slice("judge_persona_id:".length).trim().replace(/^["']|["']$/g, "");
+      if (val) {
+        const found = personas.find((p) => p.display_name === val);
+        updates.judge_persona_id = found ? found.id : val;
+      } else {
+        updates.judge_persona_id = undefined;
+      }
+    } else if (trimmed.startsWith("persona_ids:")) {
+      inPersonaIds = true;
+      const inline = trimmed.slice("persona_ids:".length).trim();
+      if (inline && inline !== "[]") {
+        inPersonaIds = false;
+      }
+    }
+  }
+
+  if (personaMapEntries.length > 0) {
+    updates.persona_ids = personaMapEntries
+      .filter((e) => e.enabled)
+      .map((e) => {
+        const found = personas.find((p) => p.display_name === e.name);
+        return found ? found.id : e.name;
+      });
+  }
+
+  return updates;
+}
+
+export async function openRoomEditor(options: RoomEditorOptions): Promise<void> {
+  const { roomId, ctx } = options;
+  const room = ctx.ei.getRoom(roomId);
+  if (!room) {
+    ctx.showNotification("Room not found", "error");
+    return;
+  }
+
+  const personas = ctx.ei.personas();
+  let yamlContent = buildRoomEditYAML(room, personas);
+
+  while (true) {
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: `${roomId}-details.yaml`,
+      renderer: ctx.renderer,
+    });
+
+    if (result.aborted) {
+      ctx.showNotification("Editor cancelled", "info");
+      return;
+    }
+
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return;
+    }
+
+    if (result.content === null) {
+      ctx.showNotification("No changes made", "info");
+      return;
+    }
+
+    try {
+      const updates = parseRoomEditYAML(result.content, personas);
+      await ctx.ei.updateRoom(roomId, updates);
+      ctx.showNotification(`Updated ${room.display_name}`, "info");
+      return;
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[room-editor] YAML parse error", { error: errorMsg });
+
+      const shouldReEdit = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
+          <ConfirmOverlay
+            message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
+            onConfirm={() => {
+              logger.debug("[room-editor] user confirmed re-edit");
+              hideForEditor();
+              resolve(true);
+            }}
+            onCancel={() => {
+              logger.debug("[room-editor] user cancelled re-edit");
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ), ctx.renderer);
+      });
+
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        continue;
+      } else {
+        ctx.showNotification("Changes discarded", "info");
+        return;
+      }
+    }
+  }
+}

package/tui/src/util/room-logic.ts

@@ -0,0 +1,8 @@
+export function checkAllPersonasResponded(
+  personaIds: string[],
+  judgePersonaId: string | undefined,
+  respondedIds: Set<string>
+): boolean {
+  const nonJudgeIds = personaIds.filter(id => id !== judgePersonaId);
+  return nonJudgeIds.length > 0 && nonJudgeIds.every(id => respondedIds.has(id));
+}

package/tui/src/util/room-parser.ts

@@ -0,0 +1,70 @@
+import YAML from "yaml";
+import { RoomMode } from "../../../src/core/types/enums.js";
+import type { RoomCreationInput, PersonaSummary } from "../../../src/core/types.js";
+
+export function buildRoomYAMLTemplate(personas: PersonaSummary[], initialName = ""): string {
+  const activePersonas = personas.filter((p) => !p.is_archived);
+  const personaLines = activePersonas.map((p) => `  ${p.display_name}: false`).join("\n");
+  return `# Room configuration
+# mode: MAP | CYP | FFA
+display_name: "${initialName}"
+mode: FFA
+persona_ids:
+${personaLines}
+# judge_persona_id: required for messages_against_persona, use display_name from persona_ids above
+judge_persona_id: ""
+initial_message: ""
+`;
+}
+
+export function parseRoomYAML(content: string, personas: PersonaSummary[]): RoomCreationInput {
+  const parsed = YAML.parse(content) as Record<string, unknown>;
+
+  const display_name = typeof parsed.display_name === "string" ? parsed.display_name.trim() : "";
+  if (!display_name) {
+    throw new Error("display_name is required");
+  }
+
+  const rawMode = typeof parsed.mode === "string" ? parsed.mode.trim().toUpperCase() : "";
+  const modeMap: Record<string, RoomMode> = {
+    MAP: RoomMode.MessagesAgainstPersona,
+    CYP: RoomMode.ChooseYourPath,
+    FFA: RoomMode.FreeForAll,
+    MESSAGES_AGAINST_PERSONA: RoomMode.MessagesAgainstPersona,
+    CHOOSE_YOUR_PATH: RoomMode.ChooseYourPath,
+    FREE_FOR_ALL: RoomMode.FreeForAll,
+  };
+  const mode = modeMap[rawMode];
+  if (!mode) {
+    throw new Error("mode must be MAP, CYP, or FFA");
+  }
+
+  let persona_ids: string[] = [];
+  if (parsed.persona_ids && typeof parsed.persona_ids === "object" && !Array.isArray(parsed.persona_ids)) {
+    persona_ids = Object.entries(parsed.persona_ids as Record<string, unknown>)
+      .filter(([, enabled]) => enabled === true)
+      .map(([name]) => {
+        const found = personas.find((p) => p.display_name === name);
+        return found ? found.id : name;
+      });
+  } else if (Array.isArray(parsed.persona_ids)) {
+    persona_ids = (parsed.persona_ids as unknown[]).map((v) => String(v).trim()).filter(Boolean);
+  }
+
+  let judge_persona_id: string | undefined;
+  const rawJudge = typeof parsed.judge_persona_id === "string" ? parsed.judge_persona_id.trim() : "";
+  if (rawJudge) {
+    const found = personas.find((p) => p.display_name === rawJudge);
+    judge_persona_id = found ? found.id : rawJudge;
+  }
+
+  const initial_message = typeof parsed.initial_message === "string" ? parsed.initial_message : "";
+
+  return {
+    display_name,
+    mode,
+    persona_ids,
+    ...(judge_persona_id ? { judge_persona_id } : {}),
+    initial_message,
+  };
+}

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

@@ -1078,3 +1078,154 @@ export function toolkitFromYAML(yamlContent: string, original: ToolProvider, too
 
   return { updates, toolUpdates };
 }
+
+// =============================================================================
+// PERSONA PREVIEW SERIALIZATION (from-person generation flow)
+// =============================================================================
+
+/**
+ * YAML template for the first editor step in /persona new — description input.
+ */
+export function descriptionEntryToYAML(personaName: string): string {
+  return `# New Persona: ${personaName}
+# Describe who this persona is. This will be used to generate traits and topics.
+# Save to generate • :q to cancel.
+
+description: |
+  
+`;
+}
+
+/**
+ * Parse the description entry YAML.
+ */
+export function descriptionFromYAML(content: string): { description: string; relationship?: string } {
+  const data = YAML.parse(content) as { description?: string; relationship?: string };
+  if (!data) throw new Error("Failed to parse YAML");
+
+  const description = (data.description ?? "").replace(/\n/g, " ").trim();
+  const relationship = data.relationship?.trim() || undefined;
+
+  return { description, relationship };
+}
+
+/**
+ * YAML template for the traits/topics review editor step.
+ */
+export function personaPreviewToYAML(
+  preview: import('../../../src/prompts/generation/types.js').PersonaGenerationResult,
+  personaName: string,
+  personName?: string,
+  previousLongDescription?: string
+): string {
+  const normalizeLine = (s: string) => s.replace(/\n/g, ' ').trim();
+
+  const headerLines: string[] = [
+    `# Persona Preview: ${personaName}`,
+  ];
+  if (personName) {
+    headerLines.push(`# Source: ${personName}`);
+  }
+  headerLines.push(`# Edit or delete entries. Save or quit to apply • :cq to cancel.`);
+  headerLines.push(``);
+  if (previousLongDescription) {
+    headerLines.push(`# Previously: ${normalizeLine(previousLongDescription)}`);
+  }
+
+  const longDescYAML = `long_description: ${JSON.stringify(normalizeLine(preview.long_description))}`;
+  const shortDescYAML = `short_description: ${JSON.stringify(normalizeLine(preview.short_description ?? ''))}`;
+  const aliasesLine = (preview.aliases && preview.aliases.length > 0)
+    ? `aliases: ${preview.aliases.join(', ')}`
+    : null;
+
+  const traitsYAML = YAML.stringify(
+    { traits: preview.traits.map(t => ({
+      name: t.name,
+      description: t.description,
+      sentiment: Math.round(t.sentiment * 100) / 100,
+      strength: Math.round(t.strength * 100) / 100,
+    }))},
+    { lineWidth: 0 }
+  );
+
+  const topicsYAML = YAML.stringify(
+    { topics: preview.topics.map(t => ({
+      name: t.name,
+      perspective: t.perspective,
+      approach: t.approach,
+      personal_stake: t.personal_stake,
+      sentiment: Math.round(t.sentiment * 100) / 100,
+      exposure_current: Math.round(t.exposure_current * 100) / 100,
+      exposure_desired: Math.round(t.exposure_desired * 100) / 100,
+    }))},
+    { lineWidth: 0 }
+  );
+
+  return [
+    headerLines.join('\n'),
+    longDescYAML,
+    shortDescYAML,
+    ...(aliasesLine ? [aliasesLine] : []),
+    traitsYAML.trimEnd(),
+    topicsYAML.trimEnd(),
+    '',
+  ].join('\n');
+}
+
+interface PreviewYAMLData {
+  long_description?: string;
+  short_description?: string;
+  traits?: Array<{
+    name: string;
+    description: string;
+    sentiment?: number;
+    strength?: number;
+  }>;
+  topics?: Array<{
+    name: string;
+    perspective: string;
+    approach: string;
+    personal_stake: string;
+    sentiment?: number;
+    exposure_current?: number;
+    exposure_desired?: number;
+  }>;
+}
+
+/**
+ * Parse the preview YAML back into traits/topics with generated IDs.
+ */
+export function personaPreviewFromYAML(content: string): { long_description: string; short_description?: string; aliases?: string[]; traits: PersonaTrait[]; topics: PersonaTopic[] } {
+  const data = YAML.parse(content) as PreviewYAMLData & { aliases?: string };
+  if (!data) throw new Error("Failed to parse YAML");
+
+  const long_description = (data.long_description ?? "").replace(/\n/g, ' ').trim();
+  const short_description = data.short_description?.replace(/\n/g, ' ').trim() || undefined;
+
+  const traits: PersonaTrait[] = (data.traits ?? []).map(t => ({
+    id: crypto.randomUUID(),
+    name: t.name,
+    description: t.description,
+    sentiment: t.sentiment ?? 0,
+    strength: t.strength ?? 0.5,
+    last_updated: new Date().toISOString(),
+  }));
+
+  const topics: PersonaTopic[] = (data.topics ?? []).map(t => ({
+    id: crypto.randomUUID(),
+    name: t.name,
+    perspective: t.perspective,
+    approach: t.approach,
+    personal_stake: t.personal_stake,
+    sentiment: t.sentiment ?? 0,
+    exposure_current: t.exposure_current ?? 0.5,
+    exposure_desired: t.exposure_desired ?? 0.5,
+    last_updated: new Date().toISOString(),
+  }));
+
+  const aliases = data.aliases
+    ? data.aliases.split(',').map((s: string) => s.trim()).filter(Boolean)
+    : undefined;
+
+  return { long_description, short_description, aliases, traits, topics };
+}