ei-tui 0.1.10 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/cli.ts

@@ -126,6 +126,63 @@ async function installOpenCodeTool(): Promise<void> {
   console.log(`  Restart OpenCode to activate.`);
 }
 
+async function installClaudeCodeMcp(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const claudeJsonPath = join(home, ".claude.json");
+
+  // Prefer shelling out to `claude mcp add` — lets Claude Code manage its own config
+  // and avoids race conditions with a live state file.
+  try {
+    const which = Bun.spawnSync(["which", "claude"], { stdout: "pipe", stderr: "pipe" });
+    if (which.exitCode === 0) {
+      const result = Bun.spawnSync(
+        ["claude", "mcp", "add", "--scope", "user", "--transport", "stdio", "ei", "--", "ei"],
+        { stdout: "pipe", stderr: "pipe" }
+      );
+      if (result.exitCode === 0) {
+        console.log(`✓ Registered Ei as Claude Code MCP server (user scope)`);
+        console.log(`  Restart Claude Code to activate.`);
+        return;
+      }
+      console.warn(`  claude mcp add failed (exit ${result.exitCode}), falling back to direct write`);
+    }
+  } catch {
+    // claude binary not found — fall through to direct write
+  }
+
+  // Fallback: direct atomic write to ~/.claude.json
+  let config: Record<string, unknown> = {};
+  try {
+    const text = await Bun.file(claudeJsonPath).text();
+    config = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    // File doesn't exist or isn't valid JSON — start fresh
+  }
+
+  // Resolve the ei binary: if running as compiled binary, argv[1] is our path;
+  // if running as 'bun src/cli.ts', fall back to 'ei' (assumed on PATH after npm install -g)
+  const isBunScript = process.argv[1]?.endsWith("/cli.ts") || process.argv[1]?.endsWith("/cli.js");
+  const command = isBunScript ? "ei" : (process.argv[1] ?? "ei");
+
+  const mcpServers = (config.mcpServers ?? {}) as Record<string, unknown>;
+  mcpServers["ei"] = {
+    type: "stdio",
+    command,
+    args: [],
+    env: {},
+  };
+  config.mcpServers = mcpServers;
+
+  // Atomic write: write to temp file then rename to avoid partial writes
+  const tmpPath = `${claudeJsonPath}.ei-install.tmp`;
+  await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
+  const { rename } = await import(/* @vite-ignore */ "fs/promises");
+  await rename(tmpPath, claudeJsonPath);
+
+  console.log(`✓ Installed Ei MCP server to ${claudeJsonPath}`);
+  console.log(`  Restart Claude Code to activate.`);
+}
+
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
 
@@ -148,6 +205,7 @@ async function main(): Promise<void> {
 
   if (args[0] === "--install") {
     await installOpenCodeTool();
+    await installClaudeCodeMcp();
     process.exit(0);
   }
 

package/src/core/handlers/index.ts

@@ -276,33 +276,88 @@ function handlePersonaGeneration(response: LLMResponse, state: StateManager): vo
 
   const now = new Date().toISOString();
 
-  const traits: Trait[] = (result?.traits || []).map(t => ({
-    id: crypto.randomUUID(),
-    name: t.name,
-    description: t.description,
-    sentiment: t.sentiment,
-    strength: t.strength,
-    last_updated: now,
-  }));
+  // Merge LLM traits into user-provided traits by name.
+  // User-provided fields win; LLM fills in what the user left blank.
+  const userTraitsByName = new Map(
+    (existingPartial.traits ?? []).filter(t => t.name?.trim()).map(t => [t.name!.toLowerCase().trim(), t])
+  );
+
+  const mergedLlmTraits: Trait[] = (result?.traits || []).map(t => {
+    const userTrait = userTraitsByName.get(t.name?.toLowerCase().trim() ?? '');
+    return {
+      id: (userTrait as Trait | undefined)?.id ?? crypto.randomUUID(),
+      name: t.name,
+      description: userTrait?.description?.trim() || t.description,
+      sentiment: userTrait?.sentiment ?? t.sentiment ?? 0,
+      strength: userTrait?.strength ?? t.strength,
+      last_updated: now,
+    };
+  });
 
-  const topics: PersonaTopic[] = (result?.topics || []).map(t => ({
-    id: crypto.randomUUID(),
-    name: t.name,
-    perspective: t.perspective || "",
-    approach: t.approach || "",
-    personal_stake: t.personal_stake || "",
-    sentiment: t.sentiment,
-    exposure_current: t.exposure_current,
-    exposure_desired: t.exposure_desired,
-    last_updated: now,
-  }));
+  // Keep user-provided traits the LLM didn't return
+  const llmTraitNames = new Set(mergedLlmTraits.map(t => t.name?.toLowerCase().trim()));
+  const preservedUserTraits: Trait[] = (existingPartial.traits ?? [])
+    .filter(t => t.name?.trim() && !llmTraitNames.has(t.name.toLowerCase().trim()))
+    .map(t => ({
+      id: (t as Trait).id ?? crypto.randomUUID(),
+      name: t.name!,
+      description: t.description || '',
+      sentiment: t.sentiment ?? 0,
+      strength: t.strength,
+      last_updated: now,
+    }));
+
+  const mergedTraits: Trait[] = mergedLlmTraits.length > 0
+    ? [...mergedLlmTraits, ...preservedUserTraits]
+    : (existingPartial.traits as Trait[] | undefined) ?? [];
+
+  // Merge LLM topics into user-provided topics by name.
+  // User-provided fields win; LLM fills in what the user left blank.
+  const userTopicsByName = new Map(
+    (existingPartial.topics ?? []).filter(t => t.name?.trim()).map(t => [t.name!.toLowerCase().trim(), t])
+  );
+
+  const llmTopics: PersonaTopic[] = (result?.topics || []).map(t => {
+    const userTopic = userTopicsByName.get(t.name?.toLowerCase().trim() ?? '');
+    return {
+      id: (userTopic as PersonaTopic | undefined)?.id ?? crypto.randomUUID(),
+      name: t.name,
+      perspective: userTopic?.perspective?.trim() || t.perspective || '',
+      approach: userTopic?.approach?.trim() || t.approach || '',
+      personal_stake: userTopic?.personal_stake?.trim() || t.personal_stake || '',
+      sentiment: userTopic?.sentiment ?? t.sentiment ?? 0,
+      exposure_current: userTopic?.exposure_current ?? t.exposure_current ?? 0.5,
+      exposure_desired: userTopic?.exposure_desired ?? t.exposure_desired ?? 0.5,
+      last_updated: now,
+    };
+  });
+
+  // Keep user-provided topics the LLM didn't return (not in its output list)
+  const llmTopicNames = new Set(llmTopics.map(t => t.name?.toLowerCase().trim()));
+  const preservedUserTopics: PersonaTopic[] = (existingPartial.topics ?? [])
+    .filter(t => t.name?.trim() && !llmTopicNames.has(t.name.toLowerCase().trim()))
+    .map(t => ({
+      id: (t as PersonaTopic).id ?? crypto.randomUUID(),
+      name: t.name!,
+      perspective: t.perspective || '',
+      approach: t.approach || '',
+      personal_stake: t.personal_stake || '',
+      sentiment: t.sentiment ?? 0,
+      exposure_current: t.exposure_current ?? 0.5,
+      exposure_desired: t.exposure_desired ?? 0.5,
+      last_updated: now,
+    }));
+
+  const topics: PersonaTopic[] = llmTopics.length > 0
+    ? [...llmTopics, ...preservedUserTopics]
+    : (existingPartial.topics as PersonaTopic[] | undefined) ?? [];
 
   const updatedPartial: PartialPersona = {
     ...existingPartial,
     short_description: result?.short_description ?? existingPartial.short_description,
     long_description: existingPartial.long_description ?? result?.long_description,
-    traits: traits.length > 0 ? traits : existingPartial.traits,
-    topics: topics.length > 0 ? topics : existingPartial.topics,
+    traits: mergedTraits.length > 0 ? mergedTraits : existingPartial.traits,
+    topics,
   };
 
   orchestratePersonaGeneration(updatedPartial, state);

package/src/core/llm-client.ts

@@ -259,7 +259,18 @@ export function parseJSONResponse(content: string): unknown {
 
 export function cleanResponseContent(content: string): string {
   return content
-    .replace(/<think>[\s\S]*?<\/think>/gi, "")
-    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
+    // Complete paired blocks (space-tolerant, case-insensitive)
+    .replace(/<\s*think\s*>[\s\S]*?<\s*\/\s*think\s*>/gi, "")
+    .replace(/<\s*thinking\s*>[\s\S]*?<\s*\/\s*thinking\s*>/gi, "")
+    // Seed-OSS (ByteDance) namespaced thinking tags — always paired
+    .replace(/<seed:think>[\s\S]*?<\/seed:think>/gi, "")
+    // Seed-OSS budget reflection tokens (may appear outside stripped think block)
+    .replace(/<seed:cot_budget_reflect>[\s\S]*?<\/seed:cot_budget_reflect>/gi, "")
+    // Orphaned closing tag with content before it (MiniMax / streaming accumulation)
+    .replace(/^[\s\S]*?<\s*\/\s*think(?:ing)?\s*>/i, "")
+    // Remaining orphaned closing tags
+    .replace(/<\s*\/\s*think(?:ing)?\s*>/gi, "")
+    // Remaining orphaned opening tags
+    .replace(/<\s*think(?:ing)?\s*>/gi, "")
     .trim();
 }

package/src/core/processor.ts

@@ -87,6 +87,7 @@ function stripHumanEmbeddings(human: HumanEntity): HumanEntity {
 const DEFAULT_LOOP_INTERVAL_MS = 100;
 const DEFAULT_CONTEXT_WINDOW_HOURS = 8;
 const DEFAULT_OPENCODE_POLLING_MS = 1800000;
+const DEFAULT_CLAUDE_CODE_POLLING_MS = 1800000;
 
 let processorInstanceCount = 0;
 
@@ -127,7 +128,11 @@ export class Processor {
   private lastOpenCodeSync = 0;
   private lastDLQTrim = 0;
   private openCodeImportInProgress = false;
+  private lastClaudeCodeSync = 0;
+  private claudeCodeImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
+  private storage: Storage | null = null;
+  private importAbortController = new AbortController();
 
   constructor(ei: Ei_Interface) {
     this.interface = ei;
@@ -147,6 +152,7 @@ export class Processor {
 
   async start(storage: Storage): Promise<void> {
     console.log(`[Processor ${this.instanceId}] start() called`);
+    this.storage = storage;
     await this.stateManager.initialize(storage);
     if (this.stopped) {
       console.log(`[Processor ${this.instanceId}] stopped during init, not starting loop`);
@@ -255,6 +261,7 @@ export class Processor {
     }
 
     this.running = false;
+    this.importAbortController.abort();
     this.queueProcessor.abort();
     await this.stateManager.flush();
     console.log(`[Processor ${this.instanceId}] stopped`);
@@ -265,10 +272,15 @@ export class Processor {
     this.interface.onSaveAndExitStart?.();
 
     this.queueProcessor.abort();
+    this.importAbortController.abort();
     if (this.openCodeImportInProgress) {
       console.log(`[Processor ${this.instanceId}] Aborting OpenCode import in progress`);
       this.openCodeImportInProgress = false;
     }
+    if (this.claudeCodeImportInProgress) {
+      console.log(`[Processor ${this.instanceId}] Aborting Claude Code import in progress`);
+      this.claudeCodeImportInProgress = false;
+    }
 
     await this.stateManager.flush();
 
@@ -325,6 +337,7 @@ export class Processor {
     }
 
     this.pendingConflict = null;
+    this.importAbortController = new AbortController();
     this.running = true;
     this.runLoop();
     this.interface.onStateImported?.();
@@ -383,6 +396,13 @@ export class Processor {
     if (this.isTUI && human.settings?.opencode?.integration && this.stateManager.queue_length() === 0) {
       await this.checkAndSyncOpenCode(human, now);
     }
+
+    if (this.isTUI && human.settings?.backup?.enabled) {
+      await this.checkAndRunRollingBackup(human, now);
+    }
+    if (this.isTUI && human.settings?.claudeCode?.integration && this.stateManager.queue_length() === 0) {
+      await this.checkAndSyncClaudeCode(human, now);
+    }
     
     if (human.settings?.ceremony && shouldStartCeremony(human.settings.ceremony, this.stateManager)) {
       // Auto-backup to remote before ceremony (if configured)
@@ -425,6 +445,33 @@ export class Processor {
     }
   }
 
+  private async checkAndRunRollingBackup(human: HumanEntity, now: number): Promise<void> {
+    if (!this.storage) return;
+    const cfg = human.settings!.backup!;
+    const intervalMs = cfg.interval_ms ?? 3_600_000;  // default: 1 hour
+    const maxBackups = cfg.max_backups ?? 24;
+    const lastBackup = cfg.last_backup ? new Date(cfg.last_backup).getTime() : 0;
+
+    if (now - lastBackup < intervalMs) return;
+
+    // Update timestamp BEFORE async work to prevent duplicate triggers
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        backup: { ...cfg, last_backup: new Date(now).toISOString() },
+      },
+    });
+
+    const state = this.stateManager.getStorageState();
+    try {
+      await this.storage.saveRollingBackup(state, maxBackups);
+      console.log(`[Processor] Rolling backup saved (max=${maxBackups})`);
+    } catch (err) {
+      console.warn(`[Processor] Rolling backup failed:`, err);
+    }
+  }
+
   private async checkAndSyncOpenCode(human: HumanEntity, now: number): Promise<void> {
     if (this.openCodeImportInProgress) {
       return;
@@ -460,6 +507,7 @@ export class Processor {
         importOpenCodeSessions({
           stateManager: this.stateManager,
           interface: this.interface,
+          signal: this.importAbortController.signal,
         })
       )
       .then((result) => {
@@ -479,6 +527,61 @@ export class Processor {
       });
   }
 
+  private async checkAndSyncClaudeCode(human: HumanEntity, now: number): Promise<void> {
+    if (this.claudeCodeImportInProgress) {
+      return;
+    }
+
+    const claudeCode = human.settings?.claudeCode;
+    const pollingInterval = claudeCode?.polling_interval_ms ?? DEFAULT_CLAUDE_CODE_POLLING_MS;
+    const lastSync = claudeCode?.last_sync
+      ? new Date(claudeCode.last_sync).getTime()
+      : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastClaudeCodeSync > 0) {
+      return;
+    }
+
+    this.lastClaudeCodeSync = now;
+    const syncTimestamp = new Date().toISOString();
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        claudeCode: {
+          ...claudeCode,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.claudeCodeImportInProgress = true;
+    import("../integrations/claude-code/importer.js")
+      .then(({ importClaudeCodeSessions }) =>
+        importClaudeCodeSessions({
+          stateManager: this.stateManager,
+          interface: this.interface,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Claude Code sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.topicsCreated} topics created, ${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Claude Code sync failed:`, err);
+      })
+      .finally(() => {
+        this.claudeCodeImportInProgress = false;
+      });
+  }
+
   private getModelForPersona(personaId?: string): string | undefined {
     const human = this.stateManager.getHuman();
     if (personaId) {
@@ -488,6 +591,11 @@ export class Processor {
     return human.settings?.default_model;
   }
 
+  private getOneshotModel(): string | undefined {
+    const human = this.stateManager.getHuman();
+    return human.settings?.oneshot_model || human.settings?.default_model;
+  }
+
   private fetchMessagesForLLM(personaId: string): import("./types.js").ChatMessage[] {
     const persona = this.stateManager.persona_getById(personaId);
     if (!persona) return [];
@@ -695,6 +803,10 @@ export class Processor {
         message += ` (attempt ${response.request.attempts}, retrying in ${Math.round(result.retryDelay / 1000)}s)`;
       } else if (result.dropped) {
         message += " (permanent failure \u2014 request removed)";
+        if (response.request.next_step === LLMNextStep.HandleOneShot) {
+          const guid = response.request.data.guid as string;
+          this.interface.onOneShotReturned?.(guid, "");
+        }
       }
 
       this.interface.onError?.({ code, message });
@@ -922,9 +1034,9 @@ export class Processor {
     const responsesToClear = [
       LLMNextStep.HandlePersonaResponse,
       LLMNextStep.HandlePersonaTraitExtraction,
-      LLMNextStep.HandlePersonaTopicScan,
-      LLMNextStep.HandlePersonaTopicMatch,
-      LLMNextStep.HandlePersonaTopicUpdate,
+      LLMNextStep.HandleHeartbeatCheck,  // clear stale heartbeat when user is active
+      LLMNextStep.HandleEiHeartbeat,     // clear stale Ei heartbeat when user is active
+      // Note: TopicScan/Match/Update are ceremony-only — never clear them here
     ];
 
     let removedAny = false;
@@ -1535,7 +1647,7 @@ export class Processor {
       system: systemPrompt,
       user: userPrompt,
       next_step: LLMNextStep.HandleOneShot,
-      model: this.getModelForPersona(),
+      model: this.getOneshotModel(),
       data: { guid },
     });
   }

package/src/core/queue-processor.ts

@@ -1,5 +1,5 @@
 import { LLMRequest, LLMResponse, LLMRequestType, ProviderAccount, ChatMessage, Message } from "./types.js";
-import { callLLMRaw, parseJSONResponse } from "./llm-client.js";
+import { callLLMRaw, parseJSONResponse, cleanResponseContent } from "./llm-client.js";
 import { hydratePromptPlaceholders } from "../prompts/message-utils.js";
 
 type QueueProcessorState = "idle" | "busy";
@@ -131,16 +131,17 @@ export class QueueProcessor {
     content: string,
     finishReason: string | null
   ): LLMResponse {
+    const cleanedContent = cleanResponseContent(content);
     switch (request.type) {
       case "json" as LLMRequestType:
       case "response" as LLMRequestType:
-        return this.handleJSONResponse(request, content, finishReason);
+        return this.handleJSONResponse(request, cleanedContent, finishReason);
       case "raw" as LLMRequestType:
       default:
         return {
           request,
           success: true,
-          content,
+          content: cleanedContent,
           finish_reason: finishReason ?? undefined,
         };
     }

package/src/core/types.ts

@@ -192,8 +192,16 @@ export interface CeremonyConfig {
   dedup_threshold?: number;  // Cosine similarity threshold for dedup candidates. Default: 0.85
 }
 
+export interface BackupConfig {
+  enabled?: boolean;       // Default: false (opt-in)
+  max_backups?: number;    // Default: 24
+  interval_ms?: number;   // Default: 3600000 (1 hour)
+  last_backup?: string;   // ISO timestamp of last backup run
+}
+
 export interface HumanSettings {
   default_model?: string;
+  oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model
   queue_paused?: boolean;
   skip_quote_delete_confirm?: boolean;
   name_display?: string;
@@ -202,6 +210,8 @@ export interface HumanSettings {
   sync?: SyncCredentials;
   opencode?: OpenCodeSettings;
   ceremony?: CeremonyConfig;
+  backup?: BackupConfig;
+  claudeCode?: import("../integrations/claude-code/types.js").ClaudeCodeSettings;
 }
 
 export interface HumanEntity {
@@ -248,7 +258,7 @@ export interface PersonaCreationInput {
   long_description?: string;
   short_description?: string;
   traits?: Partial<Trait>[];
-  topics?: Partial<Topic>[];
+  topics?: Partial<PersonaTopic>[];
   model?: string;
   group_primary?: string;
   groups_visible?: string[];