ei-tui 0.1.3

package/tui/src/util/logger.ts

@@ -0,0 +1,109 @@
+/** File-based logger for TUI debugging. Usage: tail -f $EI_DATA_PATH/tui.log */
+
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+function getDataPath(): string {
+  if (Bun.env.EI_DATA_PATH) return Bun.env.EI_DATA_PATH;
+  const xdgData = Bun.env.XDG_DATA_HOME || join(Bun.env.HOME || "~", ".local", "share");
+  return join(xdgData, "ei");
+}
+
+function getLogPath(): string {
+  return join(getDataPath(), "tui.log");
+}
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const currentLevel: LogLevel = (Bun.env.EI_LOG_LEVEL as LogLevel) || "debug";
+
+function shouldLog(level: LogLevel): boolean {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+
+function formatMessage(level: LogLevel, message: string, data?: unknown): string {
+  const timestamp = new Date().toISOString();
+  const levelStr = level.toUpperCase().padEnd(5);
+  let line = `[${timestamp}] ${levelStr} ${message}`;
+  
+  if (data !== undefined) {
+    try {
+      line += ` ${JSON.stringify(data)}`;
+    } catch {
+      line += ` [unstringifiable: ${typeof data}]`;
+    }
+  }
+  
+  return line + "\n";
+}
+
+function writeLogSync(level: LogLevel, message: string, data?: unknown): void {
+  if (!shouldLog(level)) return;
+  
+  const line = formatMessage(level, message, data);
+  
+  try {
+    appendFileSync(getLogPath(), line);
+  } catch {}
+}
+
+export const logger = {
+  debug: (message: string, data?: unknown) => writeLogSync("debug", message, data),
+  info: (message: string, data?: unknown) => writeLogSync("info", message, data),
+  warn: (message: string, data?: unknown) => writeLogSync("warn", message, data),
+  error: (message: string, data?: unknown) => writeLogSync("error", message, data),
+};
+
+export function clearLog(): void {
+  try {
+    const logPath = getLogPath();
+    const dataDir = logPath.substring(0, logPath.lastIndexOf("/"));
+    mkdirSync(dataDir, { recursive: true });
+    const header = `--- TUI Started at ${new Date().toISOString()} ---\n`;
+    Bun.write(logPath, header);
+  } catch {}
+}
+
+export function interceptConsole(): void {
+  const originalLog = console.log.bind(console);
+  const originalWarn = console.warn.bind(console);
+  const originalError = console.error.bind(console);
+  const originalDebug = console.debug.bind(console);
+  const originalInfo = console.info.bind(console);
+
+  const formatArgs = (args: unknown[]): string => {
+    return args.map(arg => 
+      typeof arg === "string" ? arg : JSON.stringify(arg)
+    ).join(" ");
+  };
+
+  console.log = (...args: unknown[]) => {
+    writeLogSync("info", `[console.log] ${formatArgs(args)}`);
+    originalLog(...args);
+  };
+  console.warn = (...args: unknown[]) => {
+    writeLogSync("warn", `[console.warn] ${formatArgs(args)}`);
+    originalWarn(...args);
+  };
+  console.error = (...args: unknown[]) => {
+    writeLogSync("error", `[console.error] ${formatArgs(args)}`);
+    originalError(...args);
+  };
+  console.debug = (...args: unknown[]) => {
+    writeLogSync("debug", `[console.debug] ${formatArgs(args)}`);
+    originalDebug(...args);
+  };
+  console.info = (...args: unknown[]) => {
+    writeLogSync("info", `[console.info] ${formatArgs(args)}`);
+    originalInfo(...args);
+  };
+}
+
+export default logger;

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

@@ -0,0 +1,181 @@
+import { spawnEditor } from "./editor.js";
+import { personaToYAML, personaFromYAML, newPersonaToYAML, newPersonaFromYAML, validateModelProvider } from "./yaml-serializers.js";
+import type { CommandContext } from "../commands/registry.js";
+import type { PersonaEntity } from "../../../src/core/types.js";
+import { logger } from "./logger.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export interface PersonaEditorOptions {
+  personaId: string;
+  persona: PersonaEntity;
+  ctx: CommandContext;
+}
+
+export interface PersonaEditorResult {
+  success: boolean;
+  cancelled: boolean;
+  personaWasModified: boolean;
+}
+
+export interface NewPersonaEditorOptions {
+  personaName: string;
+  ctx: CommandContext;
+}
+
+export interface NewPersonaEditorResult {
+  created: boolean;
+  cancelled: boolean;
+}
+
+export async function createPersonaViaEditor(options: NewPersonaEditorOptions): Promise<NewPersonaEditorResult> {
+  const { personaName, ctx } = options;
+  
+  let yamlContent = newPersonaToYAML(personaName);
+  
+  while (true) {
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: `${personaName}-new.yaml`,
+      renderer: ctx.renderer,
+    });
+    
+    if (result.aborted) {
+      ctx.showNotification("Creation cancelled", "info");
+      return { created: false, cancelled: true };
+    }
+    
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return { created: false, cancelled: false };
+    }
+    
+    if (result.content === null) {
+      ctx.showNotification("No content - persona not created", "info");
+      return { created: false, cancelled: true };
+    }
+    
+    try {
+      const parsed = newPersonaFromYAML(result.content);
+      // Validate provider name in model (case-insensitive match + auto-correct)
+      const human = await ctx.ei.getHuman();
+      const llmAccounts = human.settings?.accounts?.filter(a => a.type === "llm") ?? [];
+      parsed.model = validateModelProvider(parsed.model, llmAccounts);
+      
+      const personaId = await ctx.ei.createPersona({ 
+        name: personaName,
+        ...parsed,
+      });
+      // Ensure store has the new persona before selecting
+      // (onPersonaAdded fires refreshPersonas but doesn't await it)
+      await ctx.ei.refreshPersonas();
+      ctx.ei.selectPersona(personaId);
+      
+      ctx.showNotification(`Created ${personaName}`, "info");
+      return { created: true, cancelled: false };
+      
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[persona-editor] YAML parse error in new persona", { 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("[persona-editor] user confirmed re-edit (new)");
+              hideOverlay();
+              resolve(true);
+            }}
+            onCancel={() => {
+              logger.debug("[persona-editor] user cancelled re-edit (new)");
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ));
+      });
+      
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        await new Promise(r => setTimeout(r, 50));
+        continue;
+      } else {
+        ctx.showNotification("Creation cancelled", "info");
+        return { created: false, cancelled: true };
+      }
+    }
+  }
+}
+
+export async function openPersonaEditor(options: PersonaEditorOptions): Promise<PersonaEditorResult> {
+  const { personaId, persona, ctx } = options;
+  const allGroups = await ctx.ei.getGroupList();
+  let yamlContent = personaToYAML(persona, allGroups);
+  
+  while (true) {
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: `${personaId}-details.yaml`,
+      renderer: ctx.renderer,
+    });
+    
+    if (result.aborted) {
+      ctx.showNotification("Editor cancelled", "info");
+      return { success: false, cancelled: true, personaWasModified: false };
+    }
+    
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return { success: false, cancelled: false, personaWasModified: false };
+    }
+    
+    if (result.content === null) {
+      ctx.showNotification("No changes made", "info");
+      return { success: true, cancelled: false, personaWasModified: false };
+    }
+    
+    try {
+      const parsed = personaFromYAML(result.content, persona);
+      // Validate provider name in model (case-insensitive match + auto-correct)
+      const human = await ctx.ei.getHuman();
+      const llmAccounts = human.settings?.accounts?.filter(a => a.type === "llm") ?? [];
+      parsed.updates.model = validateModelProvider(parsed.updates.model, llmAccounts);
+      
+      await ctx.ei.updatePersona(personaId, parsed.updates);
+      
+      ctx.showNotification(`Updated ${persona.display_name}`, "info");
+      return { success: true, cancelled: false, personaWasModified: true };
+      
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[persona-editor] YAML parse error", { 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("[persona-editor] user confirmed re-edit");
+              hideOverlay();
+              resolve(true);
+            }}
+            onCancel={() => {
+              logger.debug("[persona-editor] user cancelled re-edit");
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ));
+      });
+      
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        await new Promise(r => setTimeout(r, 50));
+        continue;
+      } else {
+        ctx.showNotification("Changes discarded", "info");
+        return { success: false, cancelled: true, personaWasModified: false };
+      }
+    }
+  }
+}

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

@@ -0,0 +1,168 @@
+import { spawnEditor } from "./editor.js";
+import { newProviderToYAML, newProviderFromYAML, providerToYAML, providerFromYAML } from "./yaml-serializers.js";
+import type { CommandContext } from "../commands/registry.js";
+import type { ProviderAccount, HumanSettings } from "../../../src/core/types.js";
+import { logger } from "./logger.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export interface NewProviderEditorResult {
+  created: boolean;
+  account: ProviderAccount | null;
+  cancelled: boolean;
+}
+
+export interface EditProviderEditorResult {
+  success: boolean;
+  account: ProviderAccount | null;
+  cancelled: boolean;
+}
+
+export async function createProviderViaEditor(ctx: CommandContext): Promise<NewProviderEditorResult> {
+  let yamlContent = newProviderToYAML();
+  
+  while (true) {
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: "new-provider.yaml",
+      renderer: ctx.renderer,
+    });
+    
+    if (result.aborted) {
+      ctx.showNotification("Creation cancelled", "info");
+      return { created: false, account: null, cancelled: true };
+    }
+    
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return { created: false, account: null, cancelled: false };
+    }
+    
+    if (result.content === null) {
+      ctx.showNotification("No content - provider not created", "info");
+      return { created: false, account: null, cancelled: true };
+    }
+    
+    try {
+      const account = newProviderFromYAML(result.content);
+      
+      // Save to settings
+      const human = await ctx.ei.getHuman();
+      const accounts = [...(human.settings?.accounts ?? []), account];
+      const updates: Partial<HumanSettings> = { accounts };
+      
+      // If no system default_model, auto-set to this new provider
+      if (!human.settings?.default_model) {
+        updates.default_model = account.default_model
+          ? `${account.name}:${account.default_model}`
+          : account.name;
+      }
+      await ctx.ei.updateSettings(updates);
+      
+      ctx.showNotification(`Created provider "${account.name}"`, "info");
+      return { created: true, account, cancelled: false };
+      
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[provider-editor] YAML parse error in new provider", { error: errorMsg });
+      
+      const shouldReEdit = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay) => (
+          <ConfirmOverlay
+            message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
+            onConfirm={() => {
+              hideOverlay();
+              resolve(true);
+            }}
+            onCancel={() => {
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ));
+      });
+      
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        await new Promise(r => setTimeout(r, 50));
+        continue;
+      } else {
+        ctx.showNotification("Creation cancelled", "info");
+        return { created: false, account: null, cancelled: true };
+      }
+    }
+  }
+}
+
+export async function openProviderEditor(account: ProviderAccount, ctx: CommandContext): Promise<EditProviderEditorResult> {
+  let yamlContent = providerToYAML(account);
+  
+  while (true) {
+    const result = await spawnEditor({
+      initialContent: yamlContent,
+      filename: `${account.name}-provider.yaml`,
+      renderer: ctx.renderer,
+    });
+    
+    if (result.aborted) {
+      ctx.showNotification("Editor cancelled", "info");
+      return { success: false, account: null, cancelled: true };
+    }
+    
+    if (!result.success) {
+      ctx.showNotification("Editor failed to open", "error");
+      return { success: false, account: null, cancelled: false };
+    }
+    
+    if (result.content === null) {
+      ctx.showNotification("No changes made", "info");
+      return { success: true, account, cancelled: false };
+    }
+    
+    try {
+      const updated = providerFromYAML(result.content, account);
+      
+      // Update in settings
+      const human = await ctx.ei.getHuman();
+      const accounts = [...(human.settings?.accounts ?? [])];
+      const idx = accounts.findIndex(a => a.id === account.id);
+      if (idx >= 0) {
+        accounts[idx] = updated;
+      } else {
+        accounts.push(updated);
+      }
+      await ctx.ei.updateSettings({ accounts });
+      
+      ctx.showNotification(`Updated provider "${updated.name}"`, "info");
+      return { success: true, account: updated, cancelled: false };
+      
+    } catch (parseError) {
+      const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+      logger.debug("[provider-editor] YAML parse error", { error: errorMsg });
+      
+      const shouldReEdit = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay) => (
+          <ConfirmOverlay
+            message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
+            onConfirm={() => {
+              hideOverlay();
+              resolve(true);
+            }}
+            onCancel={() => {
+              hideOverlay();
+              resolve(false);
+            }}
+          />
+        ));
+      });
+      
+      if (shouldReEdit) {
+        yamlContent = result.content;
+        await new Promise(r => setTimeout(r, 50));
+        continue;
+      } else {
+        ctx.showNotification("Changes discarded", "info");
+        return { success: false, account: null, cancelled: true };
+      }
+    }
+  }
+}

package/tui/src/util/syntax.ts

@@ -0,0 +1,35 @@
+import { SyntaxStyle, parseColor } from "@opentui/core";
+
+export function createSolarizedDarkSyntax(): SyntaxStyle {
+  return SyntaxStyle.fromStyles({
+    default: { fg: parseColor("#839496") },
+    
+    keyword: { fg: parseColor("#859900"), bold: true },
+    string: { fg: parseColor("#2aa198") },
+    comment: { fg: parseColor("#586e75"), italic: true },
+    number: { fg: parseColor("#d33682") },
+    function: { fg: parseColor("#268bd2") },
+    type: { fg: parseColor("#b58900") },
+    operator: { fg: parseColor("#859900") },
+    variable: { fg: parseColor("#839496") },
+    
+    "markup.heading": { fg: parseColor("#268bd2"), bold: true },
+    "markup.heading.1": { fg: parseColor("#cb4b16"), bold: true, underline: true },
+    "markup.heading.2": { fg: parseColor("#268bd2"), bold: true },
+    "markup.heading.3": { fg: parseColor("#2aa198") },
+    "markup.bold": { bold: true },
+    "markup.strong": { bold: true },
+    "markup.italic": { italic: true },
+    "markup.list": { fg: parseColor("#268bd2") },
+    "markup.quote": { fg: parseColor("#586e75"), italic: true },
+    "markup.raw": { fg: parseColor("#2aa198"), bg: parseColor("#073642") },
+    "markup.link": { fg: parseColor("#268bd2"), underline: true },
+    "markup.link.label": { fg: parseColor("#2aa198"), underline: true },
+    "markup.link.url": { fg: parseColor("#268bd2"), underline: true },
+    
+    conceal: { fg: parseColor("#586e75") },
+    "punctuation.special": { fg: parseColor("#586e75") },
+  });
+}
+
+export const solarizedDarkSyntax = createSolarizedDarkSyntax();