ei-tui 0.4.3 → 0.5.1

package/tui/src/commands/archive.tsx

@@ -1,32 +1,37 @@
 import type { Command } from "./registry";
-import { PersonaListOverlay } from "../components/PersonaListOverlay";
+import { ArchivedItemsOverlay } from "../components/ArchivedItemsOverlay";
 
 export const archiveCommand: Command = {
   name: "archive",
   aliases: [],
-  description: "Archive a persona or list archived personas",
+  description: "Archive a persona or list archived personas and rooms",
   usage: "/archive [name]",
   
   async execute(args, ctx) {
     const allPersonas = ctx.ei.personas();
-    const archived = allPersonas.filter(p => p.is_archived);
+    const archivedPersonas = allPersonas.filter(p => p.is_archived);
     
     if (args.length === 0) {
-      if (archived.length === 0) {
-        ctx.showNotification("No archived personas", "info");
+      const archivedRooms = ctx.ei.getArchivedRooms();
+      if (archivedPersonas.length === 0 && archivedRooms.length === 0) {
+        ctx.showNotification("No archived personas or rooms", "info");
         return;
       }
       ctx.showOverlay((hideOverlay, _hideForEditor) => (
-        <PersonaListOverlay
-          personas={archived}
-          activePersonaId={null}
-          title="Archived Personas (Enter to unarchive)"
-          onSelect={async (personaId) => {
-            const persona = archived.find(p => p.id === personaId);
+        <ArchivedItemsOverlay
+          personas={archivedPersonas}
+          rooms={archivedRooms}
+          onSelect={async (item) => {
             hideOverlay();
-            await ctx.ei.unarchivePersona(personaId);
-            ctx.ei.selectPersona(personaId);
-            ctx.showNotification(`Unarchived and switched to ${persona?.display_name ?? personaId}`, "info");
+            if (item.kind === "persona") {
+              await ctx.ei.unarchivePersona(item.id);
+              ctx.ei.selectPersona(item.id);
+              ctx.showNotification(`Unarchived and switched to ${item.display_name}`, "info");
+            } else {
+              await ctx.ei.updateRoom(item.id, { is_archived: false });
+              ctx.ei.selectRoom(item.id);
+              ctx.showNotification(`Room "${item.display_name}" unarchived`, "info");
+            }
           }}
           onDismiss={hideOverlay}
         />
@@ -38,7 +43,18 @@ export const archiveCommand: Command = {
     const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
     
     if (!personaId) {
-      ctx.showNotification(`Persona '${nameOrAlias}' not found`, "error");
+      const roomId = ctx.ei.resolveRoomName(nameOrAlias);
+      if (roomId) {
+        const room = ctx.ei.getRoom(roomId);
+        if (room?.is_archived) {
+          ctx.showNotification(`Room "${room.display_name}" is already archived`, "warn");
+          return;
+        }
+        await ctx.ei.archiveRoom(roomId);
+        ctx.showNotification(`Room "${room?.display_name ?? nameOrAlias}" archived`, "info");
+        return;
+      }
+      ctx.showNotification(`Persona or room '${nameOrAlias}' not found`, "error");
       return;
     }
     
@@ -62,7 +78,7 @@ export const archiveCommand: Command = {
 export const unarchiveCommand: Command = {
   name: "unarchive",
   aliases: [],
-  description: "Unarchive a persona and switch to it",
+  description: "Unarchive a persona or room and switch to it",
   usage: "/unarchive <name>",
   
   async execute(args, ctx) {
@@ -74,20 +90,33 @@ export const unarchiveCommand: Command = {
     const nameOrAlias = args.join(" ");
     const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
     
-    if (!personaId) {
-      ctx.showNotification(`Archived persona '${nameOrAlias}' not found`, "error");
+    if (personaId) {
+      const persona = ctx.ei.personas().find(p => p.id === personaId);
+      
+      if (!persona?.is_archived) {
+        ctx.showNotification(`'${persona?.display_name ?? nameOrAlias}' is not archived`, "warn");
+        return;
+      }
+      
+      await ctx.ei.unarchivePersona(personaId);
+      ctx.ei.selectPersona(personaId);
+      ctx.showNotification(`Unarchived and switched to ${persona.display_name}`, "info");
       return;
     }
     
-    const persona = ctx.ei.personas().find(p => p.id === personaId);
-    
-    if (!persona?.is_archived) {
-      ctx.showNotification(`'${persona?.display_name ?? nameOrAlias}' is not archived`, "warn");
+    const roomId = ctx.ei.resolveRoomName(nameOrAlias);
+    if (roomId) {
+      const room = ctx.ei.getRoom(roomId);
+      if (!room?.is_archived) {
+        ctx.showNotification(`Room '${room?.display_name ?? nameOrAlias}' is not archived`, "warn");
+        return;
+      }
+      await ctx.ei.updateRoom(roomId, { is_archived: false });
+      ctx.ei.selectRoom(roomId);
+      ctx.showNotification(`Room "${room?.display_name ?? nameOrAlias}" unarchived`, "info");
       return;
     }
     
-    await ctx.ei.unarchivePersona(personaId);
-    ctx.ei.selectPersona(personaId);
-    ctx.showNotification(`Unarchived and switched to ${persona.display_name}`, "info");
+    ctx.showNotification(`Archived persona or room '${nameOrAlias}' not found`, "error");
   }
 };

package/tui/src/commands/capture.tsx

@@ -0,0 +1,50 @@
+import type { Command } from "./registry";
+
+export const captureCommand: Command = {
+  name: "capture",
+  aliases: [],
+  description: "Trigger extraction on current chat",
+  usage: "/capture | /capture opencode",
+
+  async execute(args, ctx) {
+    if (args.length === 0) {
+      if (ctx.ei.activeRoomId()) {
+        ctx.ei.captureRoom();
+        ctx.showNotification("Extraction queued for room", "info");
+      } else {
+        ctx.ei.capturePersona();
+        ctx.showNotification("Extraction queued", "info");
+      }
+      return;
+    }
+
+    const integrationMap: Record<string, "opencode" | "claudeCode" | "cursor"> = {
+      opencode: "opencode",
+      claudecode: "claudeCode",
+      cursor: "cursor",
+    };
+    const integrationKey = integrationMap[args[0].toLowerCase()];
+    if (integrationKey) {
+      const human = await ctx.ei.getHuman();
+      const intSettings = human.settings?.[integrationKey];
+      if (!intSettings?.integration) {
+        ctx.showNotification(`${args[0]} integration not enabled. Enable in /settings.`, "warn");
+        return;
+      }
+      // Reset last_sync to epoch to force immediate scan on next processor tick
+      await ctx.ei.updateHuman({
+        settings: {
+          ...human.settings,
+          [integrationKey]: {
+            ...intSettings,
+            last_sync: new Date(0).toISOString(),
+          },
+        },
+      });
+      ctx.showNotification(`${args[0]} scan will start on next cycle`, "info");
+      return;
+    }
+
+    ctx.showNotification("Named capture not yet supported. Use /room or /persona to switch first.", "warn");
+  },
+};

package/tui/src/commands/dedupe.tsx

@@ -11,7 +11,7 @@ function buildDedupeYAML(type: DedupeType, terms: string[], entities: Array<Topi
     `# /dedupe ${type} ${terms.map(t => t.includes(" ") ? `"${t}"` : t).join(" ")}`,
     `# Terms: ${termDisplay}`,
     `# Found ${entities.length} match${entities.length === 1 ? "" : "es"}. DELETE blocks for entries to EXCLUDE from the merge.`,
-    `# Keep at least 2. Save to confirm, :q to cancel (Vim tip: :cq quits with error — same effect, but now you know it exists).`,
+    `# Keep at least 2. Save or quit to confirm • :cq to cancel.`,
     ``,
   ].join("\n");
 
@@ -129,12 +129,7 @@ export const dedupeCommand: Command = {
       return;
     }
 
-    if (result.content === null) {
-      ctx.showNotification("No changes — dedupe cancelled", "info");
-      return;
-    }
-
-    const keptIds = parseDedupeYAML(result.content);
+    const keptIds = parseDedupeYAML(result.content ?? yamlContent);
 
     if (keptIds.length < 2) {
       ctx.showNotification("Need at least 2 entries to merge — dedupe cancelled", "error");

package/tui/src/commands/delete.tsx

@@ -9,6 +9,30 @@ export const deleteCommand: Command = {
   usage: "/delete [name]",
   
   async execute(args, ctx) {
+    if (ctx.ei.activeRoomId() && args.length === 0) {
+      const roomId = ctx.ei.activeRoomId()!;
+      const room = ctx.ei.getRoom(roomId);
+      const displayName = room?.display_name ?? roomId;
+
+      const confirmed = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay, _hideForEditor) => (
+          <ConfirmOverlay
+            message={`Archive room "${displayName}"?\nThe room will be archived and removed from the list.`}
+            onConfirm={() => { hideOverlay(); resolve(true); }}
+            onCancel={() => { hideOverlay(); resolve(false); }}
+          />
+        ), ctx.renderer);
+      });
+
+      if (confirmed) {
+        await ctx.ei.archiveRoom(roomId);
+        ctx.showNotification(`Room "${displayName}" archived`, "info");
+      } else {
+        ctx.showNotification("Cancelled", "info");
+      }
+      return;
+    }
+
     const allPersonas = ctx.ei.personas();
     const deletable = allPersonas.filter(p => p.id !== ctx.ei.activePersonaId());
     
@@ -56,6 +80,30 @@ export const deleteCommand: Command = {
     const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
     
     if (!personaId) {
+      const roomId = ctx.ei.resolveRoomName(nameOrAlias);
+      if (roomId) {
+        const room = ctx.ei.getRoom(roomId);
+        const displayName = room?.display_name ?? roomId;
+
+        const confirmed = await new Promise<boolean>((resolve) => {
+          ctx.showOverlay((hideOverlay, _hideForEditor) => (
+            <ConfirmOverlay
+              message={`Archive room "${displayName}"?\nThe room will be archived and removed from the list.`}
+              onConfirm={() => { hideOverlay(); resolve(true); }}
+              onCancel={() => { hideOverlay(); resolve(false); }}
+            />
+          ), ctx.renderer);
+        });
+
+        if (confirmed) {
+          await ctx.ei.archiveRoom(roomId);
+          ctx.showNotification(`Room "${displayName}" archived`, "info");
+        } else {
+          ctx.showNotification("Cancelled", "info");
+        }
+        return;
+      }
+
       ctx.showNotification(`Persona '${nameOrAlias}' not found`, "error");
       return;
     }

package/tui/src/commands/details.tsx

@@ -1,5 +1,6 @@
 import type { Command } from "./registry.js";
 import { openPersonaEditor } from "../util/persona-editor.js";
+import { openRoomEditor } from "../util/room-editor.js";
 
 export const detailsCommand: Command = {
   name: "details",
@@ -8,6 +9,12 @@ export const detailsCommand: Command = {
   usage: "/details [persona] - Edit specified or current persona",
   
   async execute(args, ctx) {
+    if (args.length === 0 && ctx.ei.activeRoomId()) {
+      const roomId = ctx.ei.activeRoomId()!;
+      await openRoomEditor({ roomId, ctx });
+      return;
+    }
+
     let personaId: string | null;
     
     if (args.length > 0) {

package/tui/src/commands/persona.tsx

@@ -1,17 +1,27 @@
 import type { Command } from "./registry";
 import { isReservedPersonaName } from "../../../src/core/types.js";
 import { PersonaListOverlay } from "../components/PersonaListOverlay";
-import { createPersonaViaEditor } from "../util/persona-editor.js";
+import { LoadingOverlay } from "../components/LoadingOverlay.js";
+import { PersonPickerOverlay } from "../components/PersonPickerOverlay.js";
+import type { PersonPickerItem } from "../components/PersonPickerOverlay.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+import { spawnEditor } from "../util/editor.js";
+import {
+  descriptionEntryToYAML,
+  descriptionFromYAML,
+  personaPreviewToYAML,
+  personaPreviewFromYAML,
+} from "../util/yaml-serializers.js";
 
 export const personaCommand: Command = {
   name: "persona",
   aliases: ["p"],
-  description: "Switch persona, list all, or create new",
-  usage: "/persona [name] | /persona new <name>",
-  
+  description: "Switch persona, list all, create new, or update from person",
+  usage: "/persona [name] | /persona new <name> | /persona update <personaName> <personName>",
+
   async execute(args, ctx) {
     const unarchived = ctx.ei.personas().filter(p => !p.is_archived);
-    
+
     if (args.length === 0) {
       ctx.showOverlay((hideOverlay, _hideForEditor) => (
         <PersonaListOverlay
@@ -28,7 +38,7 @@ export const personaCommand: Command = {
       ), ctx.renderer);
       return;
     }
-    
+
     if (args[0].toLowerCase() === "new") {
       if (args.length < 2) {
         ctx.showNotification("Usage: /p new <name>", "error");
@@ -39,14 +49,266 @@ export const personaCommand: Command = {
         ctx.showNotification(`Cannot use reserved name "${personaName}"`, "error");
         return;
       }
-      await createPersonaViaEditor({ personaName, ctx });
+
+      // Step 1: description editor
+      const descResult = await spawnEditor({
+        initialContent: descriptionEntryToYAML(personaName),
+        filename: `${personaName}-description.yaml`,
+        renderer: ctx.renderer,
+      });
+
+      if (descResult.aborted || descResult.content === null) {
+        ctx.showNotification("Cancelled", "info");
+        return;
+      }
+
+      let parsed: { description: string; relationship?: string };
+      try {
+        parsed = descriptionFromYAML(descResult.content);
+      } catch (e) {
+        ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
+        return;
+      }
+
+      if (!parsed.description) {
+        ctx.showNotification("No description provided", "error");
+        return;
+      }
+
+      // Step 2: generate preview with loading overlay
+      let dismissed = false;
+      const overlayCallbacks = { hideOverlay: null as (() => void) | null, hideForEditor: null as (() => void) | null };
+
+      const previewPromise = new Promise<import('../../../src/prompts/generation/types.js').PersonaGenerationResult | null>((resolve) => {
+        ctx.showOverlay((hideOverlay, hideForEditor) => {
+          overlayCallbacks.hideOverlay = hideOverlay;
+          overlayCallbacks.hideForEditor = hideForEditor;
+          return (
+            <LoadingOverlay
+              message={`Generating persona preview for "${personaName}"...`}
+              onCancel={() => {
+                dismissed = true;
+                hideOverlay();
+                resolve(null);
+              }}
+            />
+          );
+        }, ctx.renderer);
+
+        ctx.ei.generatePersonaPreview(personaName, parsed.description, parsed.relationship)
+          .then(result => {
+            if (!dismissed && overlayCallbacks.hideOverlay) {
+              resolve(result);
+            }
+          })
+          .catch(e => {
+            if (!dismissed && overlayCallbacks.hideOverlay) {
+              overlayCallbacks.hideOverlay();
+              ctx.showNotification(`Generation failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+              resolve(null);
+            }
+          });
+      });
+
+      const preview = await previewPromise;
+      if (!preview) return;
+
+      overlayCallbacks.hideForEditor?.();
+
+      // Step 3: review editor
+      const previewYAML = personaPreviewToYAML(preview, personaName);
+      const reviewResult = await spawnEditor({
+        initialContent: previewYAML,
+        filename: `${personaName}-preview.yaml`,
+        renderer: ctx.renderer,
+      });
+
+      if (reviewResult.aborted) {
+        ctx.showNotification("Cancelled", "info");
+        return;
+      }
+
+      let previewParsed: ReturnType<typeof personaPreviewFromYAML>;
+      try {
+        previewParsed = personaPreviewFromYAML(reviewResult.content ?? previewYAML);
+      } catch (e) {
+        ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
+        return;
+      }
+
+      // Step 4: create
+      const personaId = await ctx.ei.createPersona({
+        name: personaName,
+        ...previewParsed,
+      });
+      await ctx.ei.refreshPersonas();
+      ctx.ei.selectPersona(personaId);
+      ctx.showNotification(`Created ${personaName}`, "info");
       return;
     }
-    
+
+    if (args[0].toLowerCase() === "update") {
+      if (args.length < 3) {
+        ctx.showNotification("Usage: /p update <personaName> <personName>", "error");
+        return;
+      }
+      const personaName = args[1];
+      const personName = args.slice(2).join(" ");
+
+      // Step 0: resolve persona (offer to create if not found)
+      let personaId = await ctx.ei.resolvePersonaName(personaName);
+      if (!personaId) {
+        const shouldCreate = await new Promise<boolean>(resolve => {
+          ctx.showOverlay((hideOverlay) => (
+            <ConfirmOverlay
+              message={`No persona named "${personaName}". Create one?`}
+              onConfirm={() => { hideOverlay(); resolve(true); }}
+              onCancel={() => { hideOverlay(); resolve(false); }}
+            />
+          ), ctx.renderer);
+        });
+        if (!shouldCreate) return;
+        personaId = await ctx.ei.createPersona({ name: personaName });
+        await ctx.ei.refreshPersonas();
+      }
+      const persona = await ctx.ei.getPersona(personaId);
+      if (!persona) {
+        ctx.showNotification(`Could not load persona "${personaName}"`, "error");
+        return;
+      }
+
+      // Step 1: find matching people
+      const human = await ctx.ei.getHuman();
+      const matches = (human.people ?? []).filter(p =>
+        p.name.toLowerCase().includes(personName.toLowerCase())
+      );
+
+      if (matches.length === 0) {
+        ctx.showNotification(`No person named "${personName}" in your data`, "error");
+        return;
+      }
+
+      // Step 2: disambiguation if multiple matches
+      let selectedPerson: typeof matches[0];
+      if (matches.length > 1) {
+        const people: PersonPickerItem[] = matches.map(p => ({
+          id: p.id,
+          name: p.name,
+          relationship: p.relationship,
+          description: p.description,
+        }));
+
+        const choice = await new Promise<typeof matches[0] | null>((resolve) => {
+          ctx.showOverlay((hideOverlay, _hideForEditor) => (
+            <PersonPickerOverlay
+              title={`Multiple matches for "${personName}"`}
+              people={people}
+              onSelect={(item) => {
+                hideOverlay();
+                const found = matches.find(m => m.id === item.id);
+                resolve(found ?? null);
+              }}
+              onDismiss={() => {
+                hideOverlay();
+                resolve(null);
+              }}
+            />
+          ), ctx.renderer);
+        });
+
+        if (!choice) return;
+        selectedPerson = choice;
+      } else {
+        selectedPerson = matches[0];
+      }
+
+      // Step 3: generate preview with loading overlay
+      let dismissed = false;
+      const overlayCallbacks2 = { hideOverlay: null as (() => void) | null, hideForEditor: null as (() => void) | null };
+
+      const previewPromise = new Promise<import('../../../src/prompts/generation/types.js').PersonaGenerationResult | null>((resolve) => {
+        ctx.showOverlay((hideOverlay, hideForEditor) => {
+          overlayCallbacks2.hideOverlay = hideOverlay;
+          overlayCallbacks2.hideForEditor = hideForEditor;
+          return (
+            <LoadingOverlay
+              message={`Generating preview for "${persona.display_name}" from "${selectedPerson.name}"...`}
+              onCancel={() => {
+                dismissed = true;
+                hideOverlay();
+                resolve(null);
+              }}
+            />
+          );
+        }, ctx.renderer);
+
+        ctx.ei.generatePersonaPreview(
+          persona.display_name,
+          selectedPerson.description ?? '',
+          selectedPerson.relationship,
+          personaId
+        )
+          .then(result => {
+            if (!dismissed && overlayCallbacks2.hideOverlay) {
+              resolve(result);
+            }
+          })
+          .catch(e => {
+            if (!dismissed && overlayCallbacks2.hideOverlay) {
+              overlayCallbacks2.hideOverlay();
+              ctx.showNotification(`Generation failed: ${e instanceof Error ? e.message : String(e)}`, "error");
+              resolve(null);
+            }
+          });
+      });
+
+      const preview = await previewPromise;
+      if (!preview) return;
+
+      overlayCallbacks2.hideForEditor?.();
+
+      // Step 4: review editor
+      const updatePreviewYAML = personaPreviewToYAML(
+        preview,
+        persona.display_name,
+        selectedPerson.name,
+        preview.previous_long_description
+      );
+      const reviewResult = await spawnEditor({
+        initialContent: updatePreviewYAML,
+        filename: `${personaId}-update-preview.yaml`,
+        renderer: ctx.renderer,
+      });
+
+      if (reviewResult.aborted) {
+        ctx.showNotification("Cancelled", "info");
+        return;
+      }
+
+      // Step 5: parse + update
+      let previewParsed: ReturnType<typeof personaPreviewFromYAML>;
+      try {
+        previewParsed = personaPreviewFromYAML(reviewResult.content ?? updatePreviewYAML);
+      } catch (e) {
+        ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
+        return;
+      }
+
+      await ctx.ei.updatePersona(personaId, {
+        long_description: previewParsed.long_description,
+        short_description: previewParsed.short_description,
+        ...(previewParsed.aliases ? { aliases: previewParsed.aliases } : {}),
+        traits: previewParsed.traits,
+        topics: previewParsed.topics,
+      });
+      ctx.showNotification(`Updated ${persona.display_name}`, "info");
+      return;
+    }
+
     // User typed a name - resolve it to ID, then switch
     const nameOrAlias = args.join(" ");
     const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
-    
+
     if (personaId) {
       const persona = unarchived.find(p => p.id === personaId);
       ctx.ei.selectPersona(personaId);