ei-tui 0.1.3

package/tui/src/commands/context.tsx

@@ -0,0 +1,124 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+import { contextToYAML, contextFromYAML } from "../util/yaml-serializers.js";
+import { logger } from "../util/logger.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export const contextCommand: Command = {
+  name: "context",
+  aliases: ["messages"],
+  description: "Edit message context status in $EDITOR",
+  usage: "/context",
+
+  async execute(_args, ctx) {
+    const personaId = ctx.ei.activePersonaId();
+    if (!personaId) {
+      ctx.showNotification("No active persona", "error");
+      return;
+    }
+
+    const messages = ctx.ei.messages();
+    if (messages.length === 0) {
+      ctx.showNotification("No messages to edit", "info");
+      return;
+    }
+
+    const originalStatus = new Map(messages.map((m) => [m.id, m.context_status]));
+
+    let yamlContent = contextToYAML(messages);
+    let editorIteration = 0;
+
+    while (true) {
+      editorIteration++;
+      logger.debug("[context] starting editor iteration", { iteration: editorIteration });
+
+      const result = await spawnEditor({
+        initialContent: yamlContent,
+        filename: "context.yaml",
+        renderer: ctx.renderer,
+      });
+
+      logger.debug("[context] editor returned", {
+        iteration: editorIteration,
+        aborted: result.aborted,
+        success: result.success,
+        hasContent: result.content !== null,
+      });
+
+      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 parsed = contextFromYAML(result.content);
+
+        if (parsed.deletedMessageIds.length > 0) {
+          await ctx.ei.deleteMessages(personaId, parsed.deletedMessageIds);
+        }
+
+        for (const msg of parsed.messages) {
+          const orig = originalStatus.get(msg.id);
+          if (orig !== undefined && orig !== msg.context_status) {
+            await ctx.ei.setMessageContextStatus(personaId, msg.id, msg.context_status);
+          }
+        }
+
+        const deleteCount = parsed.deletedMessageIds.length;
+        const notification =
+          deleteCount > 0
+            ? `Context updated (${deleteCount} message${deleteCount === 1 ? "" : "s"} deleted)`
+            : "Context updated";
+
+        ctx.showNotification(notification, "info");
+        return;
+      } catch (parseError) {
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+        logger.debug("[context] YAML parse error, prompting for re-edit", {
+          iteration: editorIteration,
+          error: errorMsg,
+        });
+
+        const shouldReEdit = await new Promise<boolean>((resolve) => {
+          ctx.showOverlay((hideOverlay) => (
+            <ConfirmOverlay
+              message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
+              onConfirm={() => {
+                logger.debug("[context] user confirmed re-edit");
+                hideOverlay();
+                resolve(true);
+              }}
+              onCancel={() => {
+                logger.debug("[context] user cancelled re-edit");
+                hideOverlay();
+                resolve(false);
+              }}
+            />
+          ));
+        });
+
+        logger.debug("[context] shouldReEdit", { shouldReEdit, iteration: editorIteration });
+
+        if (shouldReEdit) {
+          yamlContent = result.content;
+          logger.debug("[context] continuing to next iteration");
+          await new Promise((r) => setTimeout(r, 50));
+          continue;
+        } else {
+          ctx.showNotification("Changes discarded", "info");
+          return;
+        }
+      }
+    }
+  },
+};

package/tui/src/commands/delete.tsx

@@ -0,0 +1,71 @@
+import type { Command } from "./registry";
+import { PersonaListOverlay } from "../components/PersonaListOverlay";
+import { ConfirmOverlay } from "../components/ConfirmOverlay";
+
+export const deleteCommand: Command = {
+  name: "delete",
+  aliases: ["del"],
+  description: "*Permanently* delete a persona",
+  usage: "/delete [name]",
+  
+  async execute(args, ctx) {
+    const allPersonas = ctx.ei.personas();
+    const deletable = allPersonas.filter(p => p.id !== ctx.ei.activePersonaId());
+    
+    const confirmAndDelete = async (personaId: string, displayName: string) => {
+      const confirmed = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay) => (
+          <ConfirmOverlay
+            message={`Delete "${displayName}"?\nThis cannot be undone.`}
+            onConfirm={() => { hideOverlay(); resolve(true); }}
+            onCancel={() => { hideOverlay(); resolve(false); }}
+          />
+        ));
+      });
+      
+      if (confirmed) {
+        await ctx.ei.deletePersona(personaId);
+        ctx.showNotification(`Deleted ${displayName}`, "info");
+      } else {
+        ctx.showNotification("Cancelled", "info");
+      }
+    };
+    
+    if (args.length === 0) {
+      if (deletable.length === 0) {
+        ctx.showNotification("No personas available to delete", "info");
+        return;
+      }
+      ctx.showOverlay((hideOverlay) => (
+        <PersonaListOverlay
+          personas={deletable}
+          activePersonaId={null}
+          title="Select persona to delete"
+          onSelect={async (personaId) => {
+            const persona = deletable.find(p => p.id === personaId);
+            hideOverlay();
+            await confirmAndDelete(personaId, persona?.display_name ?? personaId);
+          }}
+          onDismiss={hideOverlay}
+        />
+      ));
+      return;
+    }
+    
+    const nameOrAlias = args.join(" ");
+    const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
+    
+    if (!personaId) {
+      ctx.showNotification(`Persona '${nameOrAlias}' not found`, "error");
+      return;
+    }
+    
+    if (personaId === ctx.ei.activePersonaId()) {
+      ctx.showNotification("Cannot delete active persona. Switch to another first.", "error");
+      return;
+    }
+    
+    const persona = allPersonas.find(p => p.id === personaId);
+    await confirmAndDelete(personaId, persona?.display_name ?? nameOrAlias);
+  }
+};

package/tui/src/commands/details.tsx

@@ -0,0 +1,41 @@
+import type { Command } from "./registry.js";
+import { openPersonaEditor } from "../util/persona-editor.js";
+
+export const detailsCommand: Command = {
+  name: "details",
+  aliases: ["d"],
+  description: "Edit persona details in $EDITOR",
+  usage: "/details [persona] - Edit specified or current persona",
+  
+  async execute(args, ctx) {
+    let personaId: string | null;
+    
+    if (args.length > 0) {
+      const nameOrAlias = args.join(" ");
+      personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
+      if (!personaId) {
+        ctx.showNotification(`Persona "${nameOrAlias}" not found`, "error");
+        return;
+      }
+    } else {
+      personaId = ctx.ei.activePersonaId();
+    }
+    
+    if (!personaId) {
+      ctx.showNotification("No active persona", "error");
+      return;
+    }
+    
+    const persona = await ctx.ei.getPersona(personaId);
+    if (!persona) {
+      ctx.showNotification(`Persona not found`, "error");
+      return;
+    }
+    
+    await openPersonaEditor({
+      personaId,
+      persona,
+      ctx,
+    });
+  }
+};

package/tui/src/commands/editor.tsx

@@ -0,0 +1,46 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+
+export const editorCommand: Command = {
+  name: "editor",
+  aliases: ["e", "edit"],
+  description: "Open $EDITOR",
+  usage: "/editor - Opens editor (Ctrl+E preserves current input)",
+  
+  async execute(_args, ctx) {
+    if (!ctx.renderer) {
+      ctx.showNotification("Editor not available", "error");
+      return;
+    }
+    
+    let currentText = ctx.getInputText();
+    
+    if (currentText.startsWith("/editor") || currentText.startsWith("/edit") || currentText.startsWith("/e")) {
+      currentText = "";
+    }
+    
+    const result = await spawnEditor({
+      initialContent: currentText,
+      filename: "message.txt",
+      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;
+    }
+    
+    ctx.setInputText(result.content.trimEnd());
+    ctx.showNotification("Input updated from editor", "info");
+  }
+};

package/tui/src/commands/help.tsx

@@ -0,0 +1,12 @@
+import type { Command } from "./registry";
+import { HelpOverlay } from "../components/HelpOverlay";
+
+export const helpCommand: Command = {
+  name: "help",
+  aliases: ["h"],
+  description: "Show help screen",
+  usage: "/help or /h",
+  execute: async (_args, ctx) => {
+    ctx.showOverlay((hideOverlay) => <HelpOverlay onDismiss={hideOverlay} />);
+  },
+};

package/tui/src/commands/me.tsx

@@ -0,0 +1,145 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+import { humanToYAML, humanFromYAML } from "../util/yaml-serializers.js";
+import { logger } from "../util/logger.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+type DataType = "facts" | "traits" | "topics" | "people";
+
+const VALID_TYPES: DataType[] = ["facts", "traits", "topics", "people"];
+
+export const meCommand: Command = {
+  name: "me",
+  aliases: [],
+  description: "Edit your data in $EDITOR",
+  usage: "/me [facts|traits|topics|people]",
+  
+  async execute(args, ctx) {
+    const human = await ctx.ei.getHuman();
+    
+    const filterArg = args[0]?.toLowerCase();
+    const filterType: DataType | null = filterArg && VALID_TYPES.includes(filterArg as DataType) 
+      ? filterArg as DataType 
+      : null;
+    
+    if (filterArg && !filterType) {
+      ctx.showNotification(`Invalid type: ${filterArg}. Use: facts, traits, topics, people`, "error");
+      return;
+    }
+    
+    const filteredHuman = filterType ? {
+      ...human,
+      facts: filterType === "facts" ? human.facts : [],
+      traits: filterType === "traits" ? human.traits : [],
+      topics: filterType === "topics" ? human.topics : [],
+      people: filterType === "people" ? human.people : [],
+    } : human;
+    
+    let yamlContent = humanToYAML(filteredHuman);
+    let editorIteration = 0;
+    
+    while (true) {
+      editorIteration++;
+      logger.debug("[me] starting editor iteration", { iteration: editorIteration });
+      
+      const result = await spawnEditor({
+        initialContent: yamlContent,
+        filename: "human-data.yaml",
+        renderer: ctx.renderer,
+      });
+      
+      logger.debug("[me] editor returned", { iteration: editorIteration, aborted: result.aborted, success: result.success, hasContent: result.content !== null });
+      
+      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 parsed = humanFromYAML(result.content);
+        
+        for (const id of parsed.deletedFactIds) {
+          await ctx.ei.removeDataItem("fact", id);
+        }
+        for (const id of parsed.deletedTraitIds) {
+          await ctx.ei.removeDataItem("trait", id);
+        }
+        for (const id of parsed.deletedTopicIds) {
+          await ctx.ei.removeDataItem("topic", id);
+        }
+        for (const id of parsed.deletedPersonIds) {
+          await ctx.ei.removeDataItem("person", id);
+        }
+        
+        for (const fact of parsed.facts) {
+          await ctx.ei.upsertFact(fact);
+        }
+        for (const trait of parsed.traits) {
+          await ctx.ei.upsertTrait(trait);
+        }
+        for (const topic of parsed.topics) {
+          await ctx.ei.upsertTopic(topic);
+        }
+        for (const person of parsed.people) {
+          await ctx.ei.upsertPerson(person);
+        }
+        
+        const deleteCount = parsed.deletedFactIds.length + 
+                           parsed.deletedTraitIds.length + 
+                           parsed.deletedTopicIds.length + 
+                           parsed.deletedPersonIds.length;
+        const updateCount = parsed.facts.length + 
+                           parsed.traits.length + 
+                           parsed.topics.length + 
+                           parsed.people.length;
+        
+        ctx.showNotification(`Updated ${updateCount} items, deleted ${deleteCount}`, "info");
+        return;
+        
+      } catch (parseError) {
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+        logger.debug("[me] YAML parse error, prompting for re-edit", { iteration: editorIteration, error: errorMsg });
+        
+        const shouldReEdit = await new Promise<boolean>((resolve) => {
+          ctx.showOverlay((hideOverlay) => (
+            <ConfirmOverlay
+              message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
+              onConfirm={() => {
+                logger.debug("[me] user confirmed re-edit");
+                hideOverlay();
+                resolve(true);
+              }}
+              onCancel={() => {
+                logger.debug("[me] user cancelled re-edit");
+                hideOverlay();
+                resolve(false);
+              }}
+            />
+          ));
+        });
+        
+        logger.debug("[me] shouldReEdit", { shouldReEdit, iteration: editorIteration });
+        
+        if (shouldReEdit) {
+          yamlContent = result.content;
+          logger.debug("[me] continuing to next iteration");
+          await new Promise(r => setTimeout(r, 50));
+          continue;
+        } else {
+          ctx.showNotification("Changes discarded", "info");
+          return;
+        }
+      }
+    }
+  }
+};

package/tui/src/commands/model.ts

@@ -0,0 +1,47 @@
+import type { Command } from "./registry";
+
+export const modelCommand: Command = {
+  name: "model",
+  aliases: [],
+  description: "Set the LLM model for the current persona",
+  usage: "/model <model> or /model <provider:model>",
+  execute: async (args, ctx) => {
+    const personaId = ctx.ei.activePersonaId();
+    if (!personaId) {
+      ctx.showNotification("No persona selected", "error");
+      return;
+    }
+
+    if (args.length === 0) {
+      ctx.showNotification("Usage: /model <model> (e.g., sonnet-latest or openai:gpt-4o)", "info");
+      return;
+    }
+
+    const modelSpec = args[0];
+
+    if (modelSpec.includes(":")) {
+      // Explicit provider:model — use as-is
+      await ctx.ei.updatePersona(personaId, { model: modelSpec });
+      ctx.showNotification(`Model set to ${modelSpec}`, "info");
+      return;
+    }
+
+    // No provider specified — infer from persona's current model
+    const persona = await ctx.ei.getPersona(personaId);
+    const currentModel = persona?.model;
+
+    if (currentModel) {
+      const provider = currentModel.includes(":")
+        ? currentModel.split(":")[0]
+        : currentModel;
+      const newModel = `${provider}:${modelSpec}`;
+      await ctx.ei.updatePersona(personaId, { model: newModel });
+      ctx.showNotification(`Model set to ${newModel}`, "info");
+    } else {
+      ctx.showNotification(
+        "No provider set. Use /provider first, or specify provider:model (e.g., openai:gpt-4o)",
+        "error"
+      );
+    }
+  },
+};

package/tui/src/commands/new.ts

@@ -0,0 +1,31 @@
+import type { Command } from "./registry";
+
+export const newCommand: Command = {
+  name: "new",
+  aliases: [],
+  description: "Toggle context boundary (new convo)",
+  usage: "/new",
+  execute: async (_args, ctx) => {
+    const personaId = ctx.ei.activePersonaId();
+    if (!personaId) {
+      ctx.showNotification("No persona selected", "error");
+      return;
+    }
+
+    const persona = ctx.ei.personas().find(p => p.id === personaId);
+    const messages = ctx.ei.messages();
+    const lastMessage = messages[messages.length - 1];
+    
+    const boundaryIsActive = persona?.context_boundary && 
+      (!lastMessage || persona.context_boundary > lastMessage.timestamp);
+
+    if (boundaryIsActive) {
+      await ctx.ei.setContextBoundary(personaId, null);
+      ctx.showNotification("Context boundary cleared - previous messages restored", "info");
+    } else {
+      const timestamp = new Date().toISOString();
+      await ctx.ei.setContextBoundary(personaId, timestamp);
+      ctx.showNotification("Context boundary set - conversation starts fresh", "info");
+    }
+  },
+};

package/tui/src/commands/pause.ts

@@ -0,0 +1,46 @@
+import type { Command } from "./registry";
+import { parseDuration, formatDuration } from "../util/duration";
+
+export const pauseCommand: Command = {
+  name: "pause",
+  aliases: [],
+  description: "Pause persona (optionally for a duration)",
+  usage: "/pause [duration] - e.g., /pause 2h, /pause 1d",
+  execute: async (args, ctx) => {
+    const personaId = ctx.ei.activePersonaId();
+    if (!personaId) {
+      ctx.showNotification("No persona selected", "error");
+      return;
+    }
+
+    const personas = ctx.ei.personas();
+    const persona = personas.find(p => p.id === personaId);
+    const visibleActive = personas.filter(p => !p.is_archived && !p.is_paused);
+    
+    if (visibleActive.length <= 1) {
+      ctx.showNotification("Cannot pause - at least one persona must remain active", "error");
+      return;
+    }
+
+    const displayName = persona?.display_name ?? personaId;
+    let pauseUntil: string;
+    let message: string;
+
+    if (args.length > 0) {
+      const durationMs = parseDuration(args[0]);
+      if (!durationMs) {
+        ctx.showNotification(`Invalid duration: ${args[0]}. Use formats like 2h, 1d, 1w`, "error");
+        return;
+      }
+      const resumeTime = new Date(Date.now() + durationMs);
+      pauseUntil = resumeTime.toISOString();
+      message = `Paused ${displayName} for ${formatDuration(durationMs)}`;
+    } else {
+      pauseUntil = "0";
+      message = `Paused ${displayName} indefinitely`;
+    }
+
+    await ctx.ei.updatePersona(personaId, { is_paused: true, pause_until: pauseUntil });
+    ctx.showNotification(message, "info");
+  },
+};

package/tui/src/commands/persona.tsx

@@ -0,0 +1,58 @@
+import type { Command } from "./registry";
+import { isReservedPersonaName } from "../../../src/core/types.js";
+import { PersonaListOverlay } from "../components/PersonaListOverlay";
+import { createPersonaViaEditor } from "../util/persona-editor.js";
+
+export const personaCommand: Command = {
+  name: "persona",
+  aliases: ["p"],
+  description: "Switch persona, list all, or create new",
+  usage: "/persona [name] | /persona new <name>",
+  
+  async execute(args, ctx) {
+    const unarchived = ctx.ei.personas().filter(p => !p.is_archived);
+    
+    if (args.length === 0) {
+      ctx.showOverlay((hideOverlay) => (
+        <PersonaListOverlay
+          personas={unarchived}
+          activePersonaId={ctx.ei.activePersonaId()}
+          onSelect={(personaId) => {
+            const persona = unarchived.find(p => p.id === personaId);
+            ctx.ei.selectPersona(personaId);
+            hideOverlay();
+            ctx.showNotification(`Switched to ${persona?.display_name ?? personaId}`, "info");
+          }}
+          onDismiss={hideOverlay}
+        />
+      ));
+      return;
+    }
+    
+    if (args[0].toLowerCase() === "new") {
+      if (args.length < 2) {
+        ctx.showNotification("Usage: /p new <name>", "error");
+        return;
+      }
+      const personaName = args.slice(1).join(" ");
+      if (isReservedPersonaName(personaName)) {
+        ctx.showNotification(`Cannot use reserved name "${personaName}"`, "error");
+        return;
+      }
+      await createPersonaViaEditor({ personaName, ctx });
+      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);
+      ctx.showNotification(`Switched to ${persona?.display_name ?? nameOrAlias}`, "info");
+    } else {
+      ctx.showNotification(`No persona named "${nameOrAlias}". Run \`/p new ${nameOrAlias}\` to create.`, "warn");
+    }
+  }
+};