ei-tui 0.1.3

package/tui/src/commands/provider.tsx

@@ -0,0 +1,124 @@
+import type { Command } from "./registry";
+
+import { ProviderListOverlay, type ProviderListItem } from "../components/ProviderListOverlay";
+import { createProviderViaEditor, openProviderEditor } from "../util/provider-editor.js";
+
+/**
+ * Build provider list from user's ProviderAccount settings.
+ */
+async function getProviderList(ctx: Parameters<Command["execute"]>[1]): Promise<ProviderListItem[]> {
+  const human = await ctx.ei.getHuman();
+  const accounts = human.settings?.accounts?.filter(a => a.type === "llm") ?? [];
+  
+  return accounts.map(acc => ({
+    id: acc.id,
+    displayName: acc.name,
+    key: acc.name,
+    defaultModel: acc.default_model,
+    enabled: acc.enabled ?? true,
+  }));
+}
+
+/**
+ * Extract the provider key from a persona's current model spec.
+ * "Local LLM:llama-3" -> "Local LLM"
+ * "Local LLM" -> "Local LLM"
+ * undefined -> null
+ */
+function getActiveProviderKey(model?: string): string | null {
+  if (!model) return null;
+  return model.includes(":") ? model.split(":")[0] : model;
+}
+
+/**
+ * Set a provider (with optional default model) on the active persona.
+ */
+async function setProviderOnPersona(
+  providerKey: string,
+  defaultModel: string | undefined,
+  ctx: Parameters<Command["execute"]>[1]
+): Promise<void> {
+  const personaId = ctx.ei.activePersonaId();
+  if (!personaId) {
+    ctx.showNotification("No persona selected", "error");
+    return;
+  }
+  
+  const modelSpec = defaultModel ? `${providerKey}:${defaultModel}` : providerKey;
+  await ctx.ei.updatePersona(personaId, { model: modelSpec });
+  ctx.showNotification(`Provider set to ${modelSpec}`, "info");
+}
+
+/**
+ * Find a matching provider by name (case-insensitive).
+ */
+function findProvider(providers: ProviderListItem[], name: string): ProviderListItem | undefined {
+  const lower = name.toLowerCase();
+  return providers.find(p => 
+    p.key.toLowerCase() === lower || p.displayName.toLowerCase() === lower
+  );
+}
+
+export const providerCommand: Command = {
+  name: "provider",
+  aliases: ["providers"],
+  description: "Manage LLM providers",
+  usage: "/provider [name] | /provider new",
+  
+  async execute(args, ctx) {
+    const personaId = ctx.ei.activePersonaId();
+    const persona = personaId ? await ctx.ei.getPersona(personaId) : null;
+    const activeKey = getActiveProviderKey(persona?.model);
+    const providers = await getProviderList(ctx);
+    
+    // No args -> show overlay
+    if (args.length === 0) {
+      if (providers.length === 0) {
+        ctx.showNotification("No providers configured. Use /provider new to create one.", "info");
+        return;
+      }
+      ctx.showOverlay((hideOverlay) => (
+        <ProviderListOverlay
+          providers={providers}
+          activeProviderKey={activeKey}
+          onSelect={async (provider) => {
+            hideOverlay();
+            await setProviderOnPersona(provider.key, provider.defaultModel, ctx);
+          }}
+          onEdit={async (provider) => {
+            hideOverlay();
+            await new Promise(r => setTimeout(r, 50));
+            const human = await ctx.ei.getHuman();
+            const account = human.settings?.accounts?.find(a => a.id === provider.id);
+            if (account) {
+              await openProviderEditor(account, ctx);
+            }
+          }}
+          onNew={async () => {
+            hideOverlay();
+            await new Promise(r => setTimeout(r, 50));
+            await createProviderViaEditor(ctx);
+          }}
+          onDismiss={hideOverlay}
+        />
+      ));
+      return;
+    }
+    
+    // /provider new
+    if (args[0].toLowerCase() === "new") {
+      await createProviderViaEditor(ctx);
+      return;
+    }
+    
+    // /provider <name> -> set that provider directly
+    const name = args.join(" ");
+    const match = findProvider(providers, name);
+    
+    if (match) {
+      await setProviderOnPersona(match.key, match.defaultModel, ctx);
+    } else {
+      ctx.showNotification(`No provider named "${name}". Run \`/provider new\` to create.`, "warn");
+    }
+  }
+};

package/tui/src/commands/quit.ts

@@ -0,0 +1,22 @@
+import type { Command } from "./registry";
+
+export const quitCommand: Command = {
+  name: "quit",
+  aliases: ["q"],
+  description: "Exit the application",
+  usage: "/quit or /q (add ! or 'force' to force quit without syncing)",
+  execute: async (args, ctx) => {
+    const forceQuit = args.includes("--force") || args.includes("force");
+    
+    if (forceQuit) {
+      ctx.showNotification("Force quitting...", "info");
+      await ctx.stopProcessor();
+      ctx.renderer.setTerminalTitle("");
+      ctx.renderer.destroy();
+      process.exit(0);
+    }
+
+    ctx.showNotification("Saving and syncing...", "info");
+    await ctx.exitApp();
+  },
+};

package/tui/src/commands/quotes.tsx

@@ -0,0 +1,172 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+import { quotesToYAML, quotesFromYAML } from "../util/yaml-serializers.js";
+import { logger } from "../util/logger.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+import { QuotesOverlay } from "../components/QuotesOverlay.js";
+import type { Quote } from "../../../src/core/types.js";
+
+async function openQuotesInEditor(
+  ctx: Parameters<Command["execute"]>[1],
+  quotes: Quote[],
+  label: string
+): Promise<void> {
+  if (quotes.length === 0) {
+    ctx.showNotification(`No ${label} found`, "info");
+    return;
+  }
+
+  let yamlContent = quotesToYAML(quotes);
+  let editorIteration = 0;
+
+  while (true) {
+    editorIteration++;
+    logger.debug("[quotes] starting editor iteration", { iteration: editorIteration });
+
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: "quotes.yaml",
+      renderer: ctx.renderer,
+    });
+
+    logger.debug("[quotes] 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 = quotesFromYAML(result.content);
+
+      for (const id of parsed.deletedQuoteIds) {
+        await ctx.ei.removeQuote(id);
+      }
+
+      for (const quote of parsed.quotes) {
+        await ctx.ei.updateQuote(quote.id, quote);
+      }
+
+      const deleteCount = parsed.deletedQuoteIds.length;
+      const updateCount = parsed.quotes.length;
+
+      ctx.showNotification(`Updated ${updateCount} quotes, deleted ${deleteCount}`, "info");
+      return;
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[quotes] 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("[quotes] user confirmed re-edit");
+              hideOverlay();
+              resolve(true);
+            }}
+            onCancel={() => {
+              logger.debug("[quotes] user cancelled re-edit");
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ));
+      });
+
+      logger.debug("[quotes] shouldReEdit", { shouldReEdit, iteration: editorIteration });
+
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        logger.debug("[quotes] continuing to next iteration");
+        await new Promise((r) => setTimeout(r, 50));
+        continue;
+      } else {
+        ctx.showNotification("Changes discarded", "info");
+        return;
+      }
+    }
+  }
+}
+
+export const quotesCommand: Command = {
+  name: "quotes",
+  aliases: ["quote"],
+  description: "Manage quotes",
+  usage: "/quotes [N | search \"term\" | me | <persona>]",
+
+  async execute(args, ctx) {
+    if (args.length === 0) {
+      const all = await ctx.ei.getQuotes();
+      await openQuotesInEditor(ctx, all, "quotes");
+      return;
+    }
+
+    if (args[0] === "search" && args.length > 1) {
+      const term = args.slice(1).join(" ").replace(/^"|"$/g, "");
+      const results = await ctx.ei.searchHumanData(term, { types: ["quote"], limit: 20 });
+      await openQuotesInEditor(ctx, results.quotes, `quotes matching "${term}"`);
+      return;
+    }
+
+    if (args[0] === "me") {
+      const humanQuotes = await ctx.ei.getQuotes({ speaker: "human" });
+      await openQuotesInEditor(ctx, humanQuotes, "your quotes");
+      return;
+    }
+
+    if (/^\d+$/.test(args[0])) {
+      const index = parseInt(args[0], 10);
+      const messages = ctx.ei.messages();
+      
+      if (index < 1 || index > messages.length) {
+        ctx.showNotification(`No message at index [${index}]`, "error");
+        return;
+      }
+
+      const targetMessage = messages[index - 1];
+      const allQuotes = await ctx.ei.getQuotes();
+      const messageQuotes = allQuotes.filter(q => q.message_id === targetMessage.id);
+
+      ctx.showOverlay((hide) => (
+        <QuotesOverlay
+          quotes={messageQuotes}
+          messageIndex={index}
+          onClose={hide}
+          onEdit={async () => {
+            hide();
+            await new Promise((r) => setTimeout(r, 50));
+            await openQuotesInEditor(ctx, messageQuotes, `quotes from message [${index}]`);
+          }}
+          onDelete={async (quoteId) => {
+            await ctx.ei.removeQuote(quoteId);
+            ctx.showNotification("Quote deleted", "info");
+          }}
+        />
+      ));
+      return;
+    }
+
+    const speaker = args.join(" ");
+    const speakerQuotes = await ctx.ei.getQuotes({ speaker });
+    await openQuotesInEditor(ctx, speakerQuotes, `${speaker}'s quotes`);
+  },
+};

package/tui/src/commands/registry.test.ts

@@ -0,0 +1,137 @@
+import { test, expect, describe, beforeEach, mock } from "bun:test";
+import { parseCommandLine, registerCommand, parseAndExecute, getAllCommands, type Command, type CommandContext } from "./registry";
+
+describe("parseCommandLine", () => {
+  test("parses simple command", () => {
+    expect(parseCommandLine("quit")).toEqual(["quit"]);
+  });
+
+  test("parses command with arguments", () => {
+    expect(parseCommandLine("persona switch Ei")).toEqual(["persona", "switch", "Ei"]);
+  });
+
+  test("parses quoted arguments with spaces", () => {
+    expect(parseCommandLine('message "hello world"')).toEqual(["message", "hello world"]);
+  });
+
+  test("parses single-quoted arguments", () => {
+    expect(parseCommandLine("message 'hello world'")).toEqual(["message", "hello world"]);
+  });
+
+  test("handles empty input", () => {
+    expect(parseCommandLine("")).toEqual([]);
+  });
+
+  test("handles multiple spaces between args", () => {
+    expect(parseCommandLine("cmd   arg1    arg2")).toEqual(["cmd", "arg1", "arg2"]);
+  });
+
+  test("handles mixed quoted and unquoted", () => {
+    expect(parseCommandLine('cmd arg1 "arg 2" arg3')).toEqual(["cmd", "arg1", "arg 2", "arg3"]);
+  });
+});
+
+describe("registerCommand and getAllCommands", () => {
+  test("registers command by name", () => {
+    const testCmd: Command = {
+      name: "testcmd",
+      aliases: [],
+      description: "Test command",
+      usage: "/testcmd",
+      execute: async () => {},
+    };
+    
+    registerCommand(testCmd);
+    const commands = getAllCommands();
+    expect(commands.some(c => c.name === "testcmd")).toBe(true);
+  });
+
+  test("getAllCommands returns no duplicates from aliases", () => {
+    const cmdWithAlias: Command = {
+      name: "aliased",
+      aliases: ["a", "al"],
+      description: "Command with aliases",
+      usage: "/aliased or /a or /al",
+      execute: async () => {},
+    };
+    
+    registerCommand(cmdWithAlias);
+    const commands = getAllCommands();
+    const aliasedCommands = commands.filter(c => c.name === "aliased");
+    expect(aliasedCommands.length).toBe(1);
+  });
+});
+
+describe("parseAndExecute", () => {
+  const mockContext: CommandContext = {
+    showOverlay: mock(() => {}),
+    hideOverlay: mock(() => {}),
+    showNotification: mock(() => {}),
+    exitApp: mock(() => {}),
+    stopProcessor: mock(async () => {}),
+    ei: {
+      personas: () => [],
+      activePersona: () => null,
+      messages: () => [],
+      queueStatus: () => ({ state: "idle" as const, pending_count: 0 }),
+      notification: () => null,
+      selectPersona: () => {},
+      sendMessage: async () => {},
+      refreshPersonas: async () => {},
+      refreshMessages: async () => {},
+      abortCurrentOperation: async () => {},
+      resumeQueue: async () => {},
+      stopProcessor: async () => {},
+      showNotification: () => {},
+      createPersona: async () => {},
+      archivePersona: async () => {},
+      unarchivePersona: async () => {},
+      setContextBoundary: async () => {},
+      updatePersona: async () => {},
+    },
+  };
+
+  beforeEach(() => {
+    (mockContext.showNotification as ReturnType<typeof mock>).mockReset();
+    (mockContext.exitApp as ReturnType<typeof mock>).mockReset();
+  });
+
+  test("returns false for non-command input", async () => {
+    const result = await parseAndExecute("hello world", mockContext);
+    expect(result).toBe(false);
+  });
+
+  test("returns true for command input", async () => {
+    const result = await parseAndExecute("/help", mockContext);
+    expect(result).toBe(true);
+  });
+
+  test("shows error for unknown command", async () => {
+    await parseAndExecute("/unknownxyz", mockContext);
+    expect(mockContext.showNotification).toHaveBeenCalledWith(
+      "Unknown command: /unknownxyz",
+      "error"
+    );
+  });
+
+  test("handles force suffix (!)", async () => {
+    const forceCmd: Command = {
+      name: "forceable",
+      aliases: [],
+      description: "Forceable command",
+      usage: "/forceable",
+      execute: mock(async (args) => {
+        expect(args).toContain("--force");
+      }),
+    };
+    
+    registerCommand(forceCmd);
+    await parseAndExecute("/forceable!", mockContext);
+    expect(forceCmd.execute).toHaveBeenCalled();
+  });
+
+  test("returns true for empty command (just /)", async () => {
+    const result = await parseAndExecute("/", mockContext);
+    expect(result).toBe(true);
+  });
+});

package/tui/src/commands/registry.ts

@@ -0,0 +1,130 @@
+import type { OverlayRenderer } from "../context/overlay";
+import type { EiContextValue } from "../context/ei";
+import type { CliRenderer } from "@opentui/core";
+
+export interface Command {
+  name: string;
+  aliases: string[];
+  description: string;
+  usage: string;
+  execute: (args: string[], context: CommandContext) => Promise<void>;
+}
+
+export interface CommandContext {
+  showOverlay: (renderer: OverlayRenderer) => void;
+  hideOverlay: () => void;
+  showNotification: (msg: string, level: "error" | "warn" | "info") => void;
+  exitApp: () => Promise<void>;
+  stopProcessor: () => Promise<void>;
+  ei: EiContextValue;
+  renderer: CliRenderer;
+  setInputText: (text: string) => void;
+  getInputText: () => string;
+}
+
+const commands = new Map<string, Command>();
+const commandsByName = new Map<string, Command>();
+
+/**
+ * Parse command line input, respecting quoted strings
+ */
+export function parseCommandLine(input: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+/**
+ * Register a command by name and all aliases
+ */
+export function registerCommand(cmd: Command): void {
+  commands.set(cmd.name, cmd);
+  commandsByName.set(cmd.name, cmd);
+
+  for (const alias of cmd.aliases) {
+    commands.set(alias, cmd);
+  }
+}
+
+/**
+ * Parse and execute a command
+ * Returns true if input was a command (even if unknown), false otherwise
+ */
+export async function parseAndExecute(
+  input: string,
+  ctx: CommandContext
+): Promise<boolean> {
+  if (!input.startsWith("/")) {
+    return false;
+  }
+
+  const commandInput = input.slice(1);
+  const tokens = parseCommandLine(commandInput);
+  
+  if (tokens.length === 0) {
+    return true;
+  }
+
+  let commandName = tokens[0];
+  let hasForce = false;
+  
+  if (commandName.endsWith("!")) {
+    hasForce = true;
+    commandName = commandName.slice(0, -1);
+  }
+
+  const command = commands.get(commandName);
+  
+  if (!command) {
+    ctx.showNotification(`Unknown command: /${commandName}`, "error");
+    return true;
+  }
+
+  const args = tokens.slice(1);
+  
+  if (hasForce && !args.includes("--force")) {
+    args.unshift("--force");
+  }
+
+  try {
+    await command.execute(args, ctx);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    ctx.showNotification(`Command failed: ${errorMsg}`, "error");
+  }
+
+  return true;
+}
+
+/**
+ * Get all registered commands (no duplicates from aliases)
+ */
+export function getAllCommands(): Command[] {
+  return Array.from(commandsByName.values());
+}

package/tui/src/commands/resume.ts

@@ -0,0 +1,39 @@
+import type { Command } from "./registry";
+
+export const resumeCommand: Command = {
+  name: "resume",
+  aliases: ["unpause"],
+  description: "Resume a paused persona",
+  usage: "/resume [persona]",
+  execute: async (args, ctx) => {
+    let personaId: string | null;
+    
+    if (args.length > 0) {
+      personaId = await ctx.ei.resolvePersonaName(args.join(" "));
+      if (!personaId) {
+        ctx.showNotification(`Persona '${args.join(" ")}' not found`, "error");
+        return;
+      }
+    } else {
+      personaId = ctx.ei.activePersonaId();
+      if (!personaId) {
+        ctx.showNotification("No persona selected", "error");
+        return;
+      }
+    }
+
+    const persona = ctx.ei.personas().find(p => p.id === personaId);
+    if (!persona) {
+      ctx.showNotification("Persona not found", "error");
+      return;
+    }
+    
+    if (!persona.is_paused) {
+      ctx.showNotification(`${persona.display_name} is not paused`, "warn");
+      return;
+    }
+
+    await ctx.ei.updatePersona(personaId, { is_paused: false, pause_until: undefined });
+    ctx.showNotification(`Resumed ${persona.display_name}`, "info");
+  },
+};

package/tui/src/commands/setsync.tsx

@@ -0,0 +1,43 @@
+import type { Command } from "./registry.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export const setSyncCommand: Command = {
+  name: "setsync",
+  aliases: ["ss"],
+  description: "Set sync credentials (requires restart)",
+  usage: "/setsync <username> <passphrase>",
+
+  async execute(args, ctx) {
+    if (args.length < 2) {
+      ctx.showNotification("Usage: /setsync <username> <passphrase>", "error");
+      return;
+    }
+
+    const [username, passphrase] = args;
+
+    const confirmed = await new Promise<boolean>((resolve) => {
+      ctx.showOverlay((hideOverlay) => (
+        <ConfirmOverlay
+          message={`Set sync credentials for "${username}"?\n\nThis requires a restart. Just re-run ei once it closes!`}
+          onConfirm={() => {
+            hideOverlay();
+            resolve(true);
+          }}
+          onCancel={() => {
+            hideOverlay();
+            resolve(false);
+          }}
+        />
+      ));
+    });
+
+    if (!confirmed) {
+      ctx.showNotification("Sync setup cancelled", "info");
+      return;
+    }
+
+    await ctx.ei.updateSettings({ sync: { username, passphrase } });
+    ctx.showNotification("Sync credentials saved, restarting...", "info");
+    await ctx.exitApp();
+  },
+};