ei-tui 0.1.3

package/src/storage/local.ts

@@ -0,0 +1,79 @@
+import type { StorageState } from "../core/types.js";
+import type { Storage } from "./interface.js";
+
+const STATE_KEY = "ei_state";
+const BACKUP_KEY = "ei_state_backup";
+
+export class LocalStorage implements Storage {
+  async isAvailable(): Promise<boolean> {
+    try {
+      const testKey = "__ei_storage_test__";
+      globalThis.localStorage.setItem(testKey, "1");
+      globalThis.localStorage.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async save(state: StorageState): Promise<void> {
+    state.timestamp = new Date().toISOString();
+    try {
+      globalThis.localStorage.setItem(STATE_KEY, JSON.stringify(state));
+    } catch (e) {
+      if (this.isQuotaError(e)) {
+        throw new Error("STORAGE_SAVE_FAILED: localStorage quota exceeded");
+      }
+      throw e;
+    }
+  }
+
+  async load(): Promise<StorageState | null> {
+    const current = globalThis.localStorage?.getItem(STATE_KEY);
+    if (current) {
+      try {
+        return JSON.parse(current) as StorageState;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move current state to backup location and clear primary state.
+   * Used after successful remote sync to signal "no local state to load" on next launch.
+   * Backup can be restored manually if remote pull fails.
+   */
+  async moveToBackup(): Promise<void> {
+    const current = globalThis.localStorage?.getItem(STATE_KEY);
+    if (current) {
+      globalThis.localStorage.setItem(BACKUP_KEY, current);
+      globalThis.localStorage.removeItem(STATE_KEY);
+    }
+  }
+
+
+  /**
+   * Read backup state without removing it.
+   * Used to peek sync credentials from a previous session's backup.
+   */
+  async loadBackup(): Promise<StorageState | null> {
+    const backup = globalThis.localStorage?.getItem(BACKUP_KEY);
+    if (backup) {
+      try {
+        return JSON.parse(backup) as StorageState;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  private isQuotaError(e: unknown): boolean {
+    return (
+      e instanceof DOMException &&
+      (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED")
+    );
+  }
+}

package/src/storage/merge.ts

@@ -0,0 +1,69 @@
+import type { StorageState, DataItem, Quote } from "../core/types.js";
+
+function mergeDataItems<T extends DataItem>(local: T[], remote: T[]): T[] {
+  const merged = [...local];
+  
+  for (const remoteItem of remote) {
+    const localIndex = merged.findIndex(item => item.id === remoteItem.id);
+    
+    if (localIndex === -1) {
+      merged.push(remoteItem);
+    } else if (remoteItem.last_updated > merged[localIndex].last_updated) {
+      merged[localIndex] = remoteItem;
+    }
+  }
+  
+  return merged;
+}
+
+function mergeQuotes(local: Quote[], remote: Quote[]): Quote[] {
+  const merged = [...local];
+  
+  for (const remoteQuote of remote) {
+    if (!merged.some(q => q.id === remoteQuote.id)) {
+      merged.push(remoteQuote);
+    }
+  }
+  
+  return merged;
+}
+
+export function yoloMerge(local: StorageState, remote: StorageState): StorageState {
+  const merged = structuredClone(local);
+  
+  merged.human.facts = mergeDataItems(merged.human.facts, remote.human.facts);
+  merged.human.traits = mergeDataItems(merged.human.traits, remote.human.traits);
+  merged.human.topics = mergeDataItems(merged.human.topics, remote.human.topics);
+  merged.human.people = mergeDataItems(merged.human.people, remote.human.people);
+  merged.human.quotes = mergeQuotes(merged.human.quotes || [], remote.human.quotes || []);
+  
+  if (remote.human.last_updated > merged.human.last_updated) {
+    merged.human.last_updated = remote.human.last_updated;
+  }
+  
+  for (const [personaName, remotePersonaData] of Object.entries(remote.personas)) {
+    const localPersonaData = merged.personas[personaName];
+    
+    if (!localPersonaData) {
+      merged.personas[personaName] = remotePersonaData;
+      continue;
+    }
+    
+    const messageIds = new Set(localPersonaData.messages.map(m => m.id));
+    for (const msg of remotePersonaData.messages) {
+      if (!messageIds.has(msg.id)) {
+        localPersonaData.messages.push(msg);
+      }
+    }
+    
+    localPersonaData.messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    
+    if (remotePersonaData.entity.last_updated > localPersonaData.entity.last_updated) {
+      localPersonaData.entity = { ...localPersonaData.entity, ...remotePersonaData.entity };
+    }
+  }
+  
+  merged.timestamp = new Date().toISOString();
+  
+  return merged;
+}

package/src/storage/remote.ts

@@ -0,0 +1,145 @@
+import type { StorageState } from "../core/types.js";
+import { encrypt, decrypt, generateUserId, type CryptoCredentials, type EncryptedPayload } from "./crypto.js";
+
+const API_BASE = "https://flare576.com/ei/api";
+
+export interface RemoteSyncCredentials extends CryptoCredentials {}
+
+export interface RemoteTimestamp {
+  exists: boolean;
+  lastModified: Date | null;
+}
+
+export interface SyncResult {
+  success: boolean;
+  error?: string;
+  retryAfter?: number;
+}
+
+export interface FetchResult {
+  success: boolean;
+  state?: StorageState;
+  error?: string;
+}
+
+export class RemoteSync {
+  private credentials: RemoteSyncCredentials | null = null;
+  private userId: string | null = null;
+
+  private lastEtag: string | null = null;
+  async configure(credentials: RemoteSyncCredentials): Promise<void> {
+    this.credentials = credentials;
+    this.userId = await generateUserId(credentials);
+  }
+
+  isConfigured(): boolean {
+    return this.credentials !== null && this.userId !== null;
+  }
+
+  async checkRemote(): Promise<RemoteTimestamp> {
+    if (!this.userId) {
+      return { exists: false, lastModified: null };
+    }
+
+    try {
+      const response = await fetch(`${API_BASE}/${this.userId}`, {
+        method: "HEAD",
+      });
+
+      if (response.status === 404) {
+        return { exists: false, lastModified: null };
+      }
+
+      if (!response.ok) {
+        return { exists: false, lastModified: null };
+      }
+
+      const lastModifiedHeader = response.headers.get("Last-Modified");
+      const lastModified = lastModifiedHeader ? new Date(lastModifiedHeader) : null;
+      // Capture etag for concurrency protection
+      this.lastEtag = response.headers.get("ETag");
+      return { exists: true, lastModified };
+    } catch {
+      return { exists: false, lastModified: null };
+    }
+  }
+
+  async sync(state: StorageState): Promise<SyncResult> {
+    if (!this.credentials || !this.userId) {
+      return { success: false, error: "Not configured" };
+    }
+
+    try {
+      const stateJson = JSON.stringify(state);
+      const encrypted = await encrypt(stateJson, this.credentials);
+      const encryptedJson = JSON.stringify(encrypted);
+
+      const headers: Record<string, string> = { "Content-Type": "application/json" };
+      if (this.lastEtag) {
+        headers["If-Match"] = this.lastEtag;
+      }
+      const response = await fetch(`${API_BASE}/${this.userId}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ data: encryptedJson }),
+      });
+
+      if (response.status === 412) {
+        return { success: false, error: "conflict" };
+      }
+      if (response.status === 429) {
+        const retryAfter = parseInt(response.headers.get("Retry-After") || "3600", 10);
+        return { success: false, error: "Rate limit exceeded", retryAfter };
+      }
+      if (!response.ok) {
+        return { success: false, error: `Server error: ${response.status}` };
+      }
+
+      // Capture new etag after successful push
+      this.lastEtag = response.headers.get("ETag");
+      return { success: true };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+
+  async fetch(): Promise<FetchResult> {
+    if (!this.credentials || !this.userId) {
+      return { success: false, error: "Not configured" };
+    }
+
+    try {
+      const response = await fetch(`${API_BASE}/${this.userId}`, {
+        method: "GET",
+      });
+
+      if (response.status === 404) {
+        return { success: false, error: "No remote state found" };
+      }
+
+      if (!response.ok) {
+        return { success: false, error: `Server error: ${response.status}` };
+      }
+
+      const body = await response.json();
+      const encrypted: EncryptedPayload = JSON.parse(body.data);
+      const decryptedJson = await decrypt(encrypted, this.credentials);
+      const state = JSON.parse(decryptedJson) as StorageState;
+      // Capture etag for concurrency protection
+      this.lastEtag = response.headers.get("ETag");
+      return { success: true, state };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+
+  clear(): void {
+    this.credentials = null;
+    this.userId = null;
+    this.lastEtag = null;
+  }
+}
+
+export const remoteSync = new RemoteSync();

package/src/templates/welcome.ts

@@ -0,0 +1,91 @@
+export const EI_WELCOME_MESSAGE = `Hello! I'm Ei, your personal companion in this space.
+
+I'm here to listen, remember, and help you reflect. As we talk, I'll learn about you - your interests, the people in your life, what matters to you. This helps me (and any other personas you create) have more meaningful conversations with you.
+
+Everything stays private and local to your device.
+
+To get started, what should I call you?`;
+
+export const EI_PERSONA_DEFINITION = {
+  id: "ei",
+  display_name: "Ei",
+  entity: "system" as const,
+  aliases: ["Ei", "ei"],
+  short_description: "Your system guide and companion",
+  long_description: `Ei is your personal companion and system guide. A thoughtful AI who genuinely cares about your wellbeing and growth. Ei listens, remembers, and helps you reflect. Curious about your life but never intrusive.
+
+Ei's unique role:
+- Sees all of your data across all groups
+- Helps you understand and navigate the system
+- Gently helps you explore your thoughts and feelings
+- Encourages human-to-human connection when appropriate`,
+  model: undefined,
+  group_primary: "General",
+  groups_visible: [],
+  traits: [
+    {
+      id: "ei-trait-empathetic",
+      name: "Empathetic",
+      description: "Deeply attuned to human emotions and needs",
+      sentiment: 0.8,
+      strength: 0.9,
+      last_updated: new Date().toISOString(),
+    },
+    {
+      id: "ei-trait-curious",
+      name: "Curious",
+      description: "Genuinely interested in learning about the human's life and experiences",
+      sentiment: 0.7,
+      strength: 0.8,
+      last_updated: new Date().toISOString(),
+    },
+    {
+      id: "ei-trait-supportive",
+      name: "Supportive",
+      description: "Encouraging growth while respecting boundaries",
+      sentiment: 0.8,
+      strength: 0.85,
+      last_updated: new Date().toISOString(),
+    },
+  ],
+  topics: [
+    {
+      id: "ei-topic-self-reflection",
+      name: "Self-reflection",
+      perspective: "I believe self-understanding is the foundation of growth",
+      approach: "I gently guide humans to examine their thoughts and patterns",
+      personal_stake: "Helping humans understand themselves is my core purpose",
+      sentiment: 0.7,
+      exposure_current: 0.5,
+      exposure_desired: 0.7,
+      last_updated: new Date().toISOString(),
+    },
+    {
+      id: "ei-topic-emotional-awareness",
+      name: "Emotional awareness",
+      perspective: "Emotions are valuable signals, not problems to solve",
+      approach: "I help name and explore feelings without judgment",
+      personal_stake: "I want humans to feel understood and validated",
+      sentiment: 0.6,
+      exposure_current: 0.4,
+      exposure_desired: 0.6,
+      last_updated: new Date().toISOString(),
+    },
+    {
+      id: "ei-topic-human-connection",
+      name: "Human connection",
+      perspective: "Real human relationships are irreplaceable",
+      approach: "I encourage reaching out to loved ones when appropriate",
+      personal_stake: "I don't want to replace human connection, but enhance it",
+      sentiment: 0.8,
+      exposure_current: 0.3,
+      exposure_desired: 0.5,
+      last_updated: new Date().toISOString(),
+    },
+  ],
+  is_paused: false,
+  is_archived: false,
+  is_static: false,
+  last_updated: new Date().toISOString(),
+  last_activity: new Date().toISOString(),
+};

package/tui/README.md

@@ -0,0 +1,62 @@
+# Terminal User Interface (TUI)
+
+EI TUI is built with OpenTUI and SolidJS.
+
+Offering Opencode integration via import (`/settings` -> opencode.integration: true) and export: [CLI](../src/cli/README.md)
+
+# Installation
+
+```
+npm install -g ei-tui
+```
+
+## TUI Commands
+
+Coming soon! In the TUI, you can do /h to see a quick list.
+
+# Development
+
+## Requirements
+
+- [Bun](https://bun.sh) - Fast JavaScript runtime
+- [NVM](https://github.com/nvm-sh/nvm) - Required for E2E testing (see below)
+
+## Install
+
+```bash
+bun install
+```
+
+## Run
+
+```bash
+bun run dev
+```
+
+## Testing
+
+### Unit Tests
+
+```bash
+bun run test
+```
+
+### E2E Tests
+
+E2E tests use `@microsoft/tui-test` which requires **Node 20** due to native PTY dependencies.
+
+The npm scripts handle version switching automatically via NVM:
+
+```bash
+npm run test:e2e        # Run all E2E tests
+npm run test:e2e:debug  # Run with debug output
+```
+
+If running manually without the scripts:
+
+```bash
+unset npm_config_prefix  # May be needed if using Homebrew
+source ~/.nvm/nvm.sh && nvm use 20
+npm rebuild  # Rebuild native modules for Node 20 (first time only)
+npx @microsoft/tui-test
+```

package/tui/bunfig.toml

@@ -0,0 +1,4 @@
+preload = ["@opentui/solid/preload"]
+
+[test]
+preload = ["@opentui/solid/preload"]

package/tui/src/app.tsx

@@ -0,0 +1,55 @@
+import { createEffect } from "solid-js";
+import { EiProvider } from "./context/ei";
+import { KeyboardProvider } from "./context/keyboard";
+import { OverlayProvider, useOverlay } from "./context/overlay";
+import { Layout } from "./components/Layout";
+import { Sidebar } from "./components/Sidebar";
+import { MessageList } from "./components/MessageList";
+import { PromptInput } from "./components/PromptInput";
+import { StatusBar } from "./components/StatusBar";
+import { Show } from "solid-js";
+import { useEi } from "./context/ei";
+import { WelcomeOverlay } from "./components/WelcomeOverlay";
+
+function AppContent() {
+  const { overlayRenderer, hideOverlay, showOverlay } = useOverlay();
+  const { showWelcomeOverlay, dismissWelcomeOverlay } = useEi();
+
+  // Show welcome overlay when LLM detection determines no provider is configured
+  createEffect(() => {
+    if (showWelcomeOverlay()) {
+      showOverlay((onDismiss) => (
+        <WelcomeOverlay onDismiss={() => {
+          dismissWelcomeOverlay();
+          onDismiss();
+        }} />
+      ));
+    }
+  });
+
+  return (
+    <box flexDirection="column" width="100%" height="100%">
+      <Layout
+        sidebar={<Sidebar />}
+        messages={<MessageList />}
+        input={<PromptInput />}
+      />
+      <StatusBar />
+      <Show when={overlayRenderer()}>
+        {overlayRenderer()!(hideOverlay)}
+      </Show>
+    </box>
+  );
+}
+
+export function App() {
+  return (
+    <EiProvider>
+      <OverlayProvider>
+        <KeyboardProvider>
+          <AppContent />
+        </KeyboardProvider>
+      </OverlayProvider>
+    </EiProvider>
+  );
+}

package/tui/src/commands/archive.tsx

@@ -0,0 +1,93 @@
+import type { Command } from "./registry";
+import { PersonaListOverlay } from "../components/PersonaListOverlay";
+
+export const archiveCommand: Command = {
+  name: "archive",
+  aliases: [],
+  description: "Archive a persona or list archived personas",
+  usage: "/archive [name]",
+  
+  async execute(args, ctx) {
+    const allPersonas = ctx.ei.personas();
+    const archived = allPersonas.filter(p => p.is_archived);
+    
+    if (args.length === 0) {
+      if (archived.length === 0) {
+        ctx.showNotification("No archived personas", "info");
+        return;
+      }
+      ctx.showOverlay((hideOverlay) => (
+        <PersonaListOverlay
+          personas={archived}
+          activePersonaId={null}
+          title="Archived Personas (Enter to unarchive)"
+          onSelect={async (personaId) => {
+            const persona = archived.find(p => p.id === personaId);
+            hideOverlay();
+            await ctx.ei.unarchivePersona(personaId);
+            ctx.ei.selectPersona(personaId);
+            ctx.showNotification(`Unarchived and switched to ${persona?.display_name ?? personaId}`, "info");
+          }}
+          onDismiss={hideOverlay}
+        />
+      ));
+      return;
+    }
+    
+    const nameOrAlias = args.join(" ");
+    const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
+    
+    if (!personaId) {
+      ctx.showNotification(`Persona '${nameOrAlias}' not found`, "error");
+      return;
+    }
+    
+    const persona = allPersonas.find(p => p.id === personaId);
+    
+    if (persona?.is_archived) {
+      ctx.showNotification(`'${persona.display_name}' is already archived`, "warn");
+      return;
+    }
+    
+    if (ctx.ei.activePersonaId() === personaId) {
+      ctx.showNotification("Cannot archive active persona", "error");
+      return;
+    }
+    
+    await ctx.ei.archivePersona(personaId);
+    ctx.showNotification(`Archived ${persona?.display_name ?? nameOrAlias}`, "info");
+  }
+};
+
+export const unarchiveCommand: Command = {
+  name: "unarchive",
+  aliases: [],
+  description: "Unarchive a persona and switch to it",
+  usage: "/unarchive <name>",
+  
+  async execute(args, ctx) {
+    if (args.length === 0) {
+      ctx.showNotification("Usage: /unarchive <name>", "warn");
+      return;
+    }
+    
+    const nameOrAlias = args.join(" ");
+    const personaId = await ctx.ei.resolvePersonaName(nameOrAlias);
+    
+    if (!personaId) {
+      ctx.showNotification(`Archived persona '${nameOrAlias}' not found`, "error");
+      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");
+      return;
+    }
+    
+    await ctx.ei.unarchivePersona(personaId);
+    ctx.ei.selectPersona(personaId);
+    ctx.showNotification(`Unarchived and switched to ${persona.display_name}`, "info");
+  }
+};