ei-tui 1.6.3 → 1.6.5

package/src/core/migrations.ts

@@ -0,0 +1,297 @@
+import { StateManager } from "./state-manager.js";
+import type { Fact } from "./types.js";
+import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
+import { isQualifiedMessageId, qualifyEiMessage, qualifyOpenCodeMessage } from "./utils/message-id.js";
+import type { IOpenCodeReader } from "../integrations/opencode/types.js";
+
+export function seedBuiltinFacts(stateManager: StateManager): void {
+  const human = stateManager.getHuman();
+  const existingFactNames = new Set(human.facts.map(f => f.name));
+  
+  const now = new Date().toISOString();
+  let seededCount = 0;
+
+  for (const builtInFact of BUILT_IN_FACTS) {
+    if (existingFactNames.has(builtInFact.name)) continue;
+
+    const newFact: Fact = {
+      id: crypto.randomUUID(),
+      name: builtInFact.name,
+      description: '',
+      sentiment: 0,
+      validated_date: '',
+      last_updated: now,
+      learned_on: now,
+    };
+    human.facts.push(newFact);
+    seededCount++;
+  }
+
+  if (seededCount > 0) {
+    stateManager.setHuman(human);
+    console.log(`[Processor] Seeded ${seededCount} built-in facts`);
+  }
+}
+
+export function migrateLearnedOn(stateManager: StateManager): void {
+  const human = stateManager.getHuman();
+
+  const backfill = <T extends { learned_on?: string; last_updated: string }>(items: T[]): T[] =>
+    items.map(item => item.learned_on ? item : { ...item, learned_on: item.last_updated });
+
+  const facts = backfill(human.facts);
+  const topics = backfill(human.topics);
+  const people = backfill(human.people);
+
+  const changed =
+    facts.some((f, i) => f !== human.facts[i]) ||
+    topics.some((t, i) => t !== human.topics[i]) ||
+    people.some((p, i) => p !== human.people[i]);
+
+  if (changed) {
+    stateManager.setHuman({ ...human, facts, topics, people });
+    console.log("[Processor] Backfilled learned_on for existing data items");
+  }
+}
+
+export async function migrateMessageIds(stateManager: StateManager, isTUI: boolean): Promise<void> {
+  try {
+    let msgRewrites = 0;
+    let quoteRewrites = 0;
+
+    const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+    const personas = stateManager.persona_getAll();
+    for (const persona of personas) {
+      for (const msg of stateManager.messages_get(persona.id)) {
+        if (!msg.external && UUID_PATTERN.test(msg.id)) {
+          stateManager.messages_update(persona.id, msg.id, { id: qualifyEiMessage(msg.id) });
+          msgRewrites++;
+        }
+      }
+    }
+
+    const rooms = stateManager.getRoomList(true);
+    for (const room of rooms) {
+      const roomIdRewrites = new Map<string, string>();
+
+      for (const msg of stateManager.getRoomMessages(room.id).slice()) {
+        if (UUID_PATTERN.test(msg.id)) {
+          const fqId = qualifyEiMessage(msg.id);
+          roomIdRewrites.set(msg.id, fqId);
+          stateManager.updateRoomMessage(room.id, msg.id, { id: fqId });
+          msgRewrites++;
+        }
+      }
+
+      let parentRewrites = 0;
+      for (const msg of stateManager.getRoomMessages(room.id)) {
+        const pid = msg.parent_id;
+        if (pid && UUID_PATTERN.test(pid)) {
+          const fqPid = roomIdRewrites.get(pid) ?? qualifyEiMessage(pid);
+          stateManager.updateRoomMessage(room.id, msg.id, { parent_id: fqPid });
+          parentRewrites++;
+        }
+      }
+
+      const activeNode = room.active_node_id;
+      if (activeNode && UUID_PATTERN.test(activeNode)) {
+        const fqActive = roomIdRewrites.get(activeNode) ?? qualifyEiMessage(activeNode);
+        stateManager.updateRoom(room.id, { active_node_id: fqActive });
+      }
+
+      if (parentRewrites > 0) {
+        msgRewrites += parentRewrites;
+      }
+    }
+
+    const human = stateManager.getHuman();
+    const quotes = human.quotes ?? [];
+
+    const eiUuidMap = new Map<string, string>();
+    for (const persona of personas) {
+      for (const msg of stateManager.messages_get(persona.id)) {
+        if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+      }
+    }
+    for (const room of rooms) {
+      for (const msg of stateManager.getRoomMessages(room.id)) {
+        if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+      }
+    }
+
+    const MSG_PATTERN = /^msg_[a-zA-Z0-9]+$/;
+
+    let openCodeReader: IOpenCodeReader | null = null;
+    if (isTUI) {
+      const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+      openCodeReader = await createOpenCodeReader().catch(() => null);
+    }
+
+    const updatedQuotes: typeof quotes = [];
+    for (const quote of quotes) {
+      const mid = quote.message_id;
+      if (!mid || isQualifiedMessageId(mid)) {
+        updatedQuotes.push(quote);
+        continue;
+      }
+
+      if (MSG_PATTERN.test(mid)) {
+        if (openCodeReader) {
+          const ocWindow = await openCodeReader.getMessageById(mid).catch(() => null);
+          if (ocWindow) {
+            const { getMachineId } = await import("../integrations/machine-id.js");
+            updatedQuotes.push({ ...quote, message_id: qualifyOpenCodeMessage(getMachineId(), ocWindow.session.id, mid) });
+            quoteRewrites++;
+            continue;
+          }
+        }
+        updatedQuotes.push(quote);
+        continue;
+      }
+
+      if (UUID_PATTERN.test(mid)) {
+        const fqId = eiUuidMap.get(mid);
+        if (fqId) {
+          updatedQuotes.push({ ...quote, message_id: fqId });
+          quoteRewrites++;
+          continue;
+        }
+        updatedQuotes.push(quote);
+        continue;
+      }
+
+      updatedQuotes.push(quote);
+    }
+
+    if (quoteRewrites > 0) {
+      stateManager.setHuman({ ...human, quotes: updatedQuotes });
+    }
+
+    if (msgRewrites > 0 || quoteRewrites > 0) {
+      console.log(`[Processor] migrateMessageIds: rewrote ${msgRewrites} message IDs, ${quoteRewrites} quote message_ids`);
+    }
+  } catch (err) {
+    console.error("[Processor] migrateMessageIds failed, continuing:", err);
+  }
+}
+
+export function migrateSlackToMultiWorkspace(stateManager: StateManager): void {
+  const human = stateManager.getHuman();
+  const slack = human.settings?.slack as Record<string, unknown> | undefined;
+  if (!slack) return;
+
+  const hasLegacyAuth = "auth" in slack && slack.auth != null;
+  const hasLegacyIntegration = "integration" in slack;
+  if (!hasLegacyAuth && !hasLegacyIntegration) return;
+
+  const legacyAuth = slack.auth as Record<string, unknown> | undefined;
+  const workspaceId = (legacyAuth?.workspace_id as string | undefined) ?? "unknown";
+
+  const migratedWorkspace: Record<string, unknown> = {
+    integration: slack.integration,
+    extraction_model: slack.extraction_model,
+    last_sync: slack.last_sync,
+    backfill_days: slack.backfill_days,
+    broadcast_threshold: slack.broadcast_threshold,
+    channel_overrides: slack.channel_overrides,
+    channels: slack.channels,
+  };
+
+  if (legacyAuth) {
+    migratedWorkspace.auth = {
+      type: "oauth",
+      token: legacyAuth.token,
+      refresh_token: legacyAuth.refresh_token,
+      workspace_name: legacyAuth.workspace_name,
+    };
+  }
+
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      slack: {
+        polling_interval_ms: slack.polling_interval_ms as number | undefined,
+        workspaces: { [workspaceId]: migratedWorkspace } as unknown as import("../integrations/slack/types.js").SlackSettings["workspaces"],
+      },
+    },
+  });
+
+  console.log(`[Processor] migrateSlackToMultiWorkspace: migrated legacy slack settings to workspaces[${workspaceId}]`);
+}
+
+export function seedSettings(stateManager: StateManager): void {
+  const human = stateManager.getHuman();
+  let modified = false;
+
+  if (!human.settings) {
+    human.settings = {};
+    modified = true;
+  }
+
+  if (!human.settings.opencode) {
+    human.settings.opencode = {
+      integration: false,
+      polling_interval_ms: 60000,
+    };
+    modified = true;
+  }
+
+  if (!human.settings.claudeCode) {
+    human.settings.claudeCode = {
+      integration: false,
+      polling_interval_ms: 60000,
+    };
+    modified = true;
+  }
+
+  if (!human.settings.codex) {
+    human.settings.codex = {
+      integration: false,
+      polling_interval_ms: 60000,
+    };
+    modified = true;
+  }
+
+  if (!human.settings.ceremony) {
+    human.settings.ceremony = {
+      time: "09:00",
+    };
+    modified = true;
+  }
+
+  if (!human.settings.backup) {
+    human.settings.backup = {
+      enabled: false,
+      max_backups: 24,
+      interval_ms: 3600000,
+    };
+    modified = true;
+  }
+
+  if (human.settings.default_heartbeat_ms == null) {
+    human.settings.default_heartbeat_ms = 1800000;
+    modified = true;
+  }
+
+  if (human.settings.default_context_window_ms == null) {
+    human.settings.default_context_window_ms = 28800000;
+    modified = true;
+  }
+
+  if (human.settings.message_min_count == null) {
+    human.settings.message_min_count = 0;
+    modified = true;
+  }
+
+  if (human.settings.message_max_age_days == null) {
+    human.settings.message_max_age_days = 0;
+    modified = true;
+  }
+
+  if (modified) {
+    stateManager.setHuman(human);
+    console.log(`[Processor] Seeded missing settings`);
+  }
+}

package/src/core/orchestrators/ceremony.ts

@@ -17,6 +17,7 @@ import { buildPersonRewriteScanPrompt } from "../../prompts/ceremony/people-rewr
 import { buildTopicRewriteScanPrompt } from "../../prompts/ceremony/topic-rewrite.js";
 import { buildReflectionCriticPrompt } from "../../prompts/reflection/index.js";
 import { getModelForPersona } from "../heartbeat-manager.js";
+import { qualifyEiMessage } from "../utils/message-id.js";
 
 const PERSON_LOG_REFLECTION_THRESHOLD = 3000;
 
@@ -641,7 +642,7 @@ function queueReflectionPhase(state: StateManager): boolean {
       console.log(`[ceremony:reflection] ${persona.display_name} is linked to multiple person records (${names}) — skipping reflection, writing Ei warning`);
 
       const warning: Message = {
-        id: crypto.randomUUID(),
+        id: qualifyEiMessage(crypto.randomUUID()),
         role: "system",
         content: `During today's ceremony, I noticed that **${persona.display_name}** is connected to multiple person records: ${names}. This might be intentional — if you created a composite persona — but if not, you may want to check the identifiers on those records. Reflection for ${persona.display_name} has been paused until this is resolved.`,
         timestamp: new Date().toISOString(),