ei-tui 0.6.0 → 0.6.1

package/package.json

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

package/src/core/handlers/human-matching.ts

@@ -123,10 +123,6 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
   const roomId = response.request.data.roomId as string | undefined;
   const candidateCategory = response.request.data.candidateCategory as string | undefined;
 
-  if (!result.name || !result.description || result.sentiment === undefined) {
-    throw new Error(`[handleTopicUpdate] Missing required fields: name=${result.name}, description=${!!result.description}, sentiment=${result.sentiment}`);
-  }
-
   const personaIds = personaId.split("|").filter(Boolean);
   const primaryId = personaIds[0] ?? personaId;
 
@@ -147,14 +143,21 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
 
   const existingTopic = isNewItem ? undefined : human.topics.find(t => t.id === existingItemId);
 
+  const resolvedName = result.name || existingTopic?.name;
+  const resolvedDescription = typeof result.description === 'string' ? result.description : existingTopic?.description;
+
+  if (!resolvedName || !resolvedDescription || result.sentiment === undefined) {
+    throw new Error(`[handleTopicUpdate] Missing required fields: name=${resolvedName}, description=${!!resolvedDescription}, sentiment=${result.sentiment}`);
+  }
+
   let embedding: number[] | undefined;
   try {
     const embeddingService = getEmbeddingService();
     const category = result.category ?? candidateCategory ?? existingTopic?.category;
-    const text = getTopicEmbeddingText({ name: result.name, category, description: result.description });
+    const text = getTopicEmbeddingText({ name: resolvedName, category, description: resolvedDescription });
     embedding = await embeddingService.embed(text);
   } catch (err) {
-    console.warn(`[handleTopicUpdate] Failed to compute embedding for topic "${result.name}":`, err);
+    console.warn(`[handleTopicUpdate] Failed to compute embedding for topic "${resolvedName}":`, err);
   }
 
   const exposureImpact = result.exposure_impact as ExposureImpact | undefined;
@@ -167,8 +170,8 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
 
   const topic: Topic = {
     id: itemId,
-    name: result.name,
-    description: result.description,
+    name: resolvedName,
+    description: resolvedDescription,
     sentiment: result.sentiment,
     category: result.category ?? candidateCategory ?? existingTopic?.category,
     exposure_current: calculateExposureCurrent(exposureImpact, existingTopic?.exposure_current ?? 0),
@@ -189,7 +192,7 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     : state.messages_get(personaId);
   await validateAndStoreQuotes(result.quotes, allMessages, itemId, personaDisplayName, personaGroup, state);
 
-  console.log(`[handleTopicUpdate] ${isNewItem ? "Created" : "Updated"} topic "${result.name}"`);
+  console.log(`[handleTopicUpdate] ${isNewItem ? "Created" : "Updated"} topic "${resolvedName}"`);
 }
 
 export async function handlePersonUpdate(response: LLMResponse, state: StateManager): Promise<void> {

package/src/prompts/human/topic-update.ts

@@ -250,7 +250,7 @@ ONLY ANALYZE the "Most Recent Messages". The "Earlier Conversation" is provided
 ${jsonTemplate}
 \`\`\`
 
-When returning a record, **ALWAYS** include \`name\`, \`description\`, and \`sentiment\`.
+When returning a record, always include \`sentiment\`. Include \`name\` only if you are changing it; omit it to keep the existing name. Always include \`description\` when returning a record.
 
 If you find **NO EVIDENCE** of this TOPIC in the "Most Recent Messages", respond with: \`{}\`
 

package/tui/src/commands/me.tsx

@@ -80,21 +80,27 @@ export const meCommand: Command = {
         }
         
         for (const fact of parsed.facts) {
-          await ctx.ei.upsertFact(fact);
+          if (parsed.changedFactIds.has(fact.id)) {
+            await ctx.ei.upsertFact(fact);
+          }
         }
         for (const topic of parsed.topics) {
-          await ctx.ei.upsertTopic(topic);
+          if (parsed.changedTopicIds.has(topic.id)) {
+            await ctx.ei.upsertTopic(topic);
+          }
         }
         for (const person of parsed.people) {
-          await ctx.ei.upsertPerson(person);
+          if (parsed.changedPersonIds.has(person.id)) {
+            await ctx.ei.upsertPerson(person);
+          }
         }
         
         const deleteCount = parsed.deletedFactIds.length + 
                            parsed.deletedTopicIds.length + 
                            parsed.deletedPersonIds.length;
-        const updateCount = parsed.facts.length + 
-                           parsed.topics.length + 
-                           parsed.people.length;
+        const updateCount = parsed.changedFactIds.size + 
+                           parsed.changedTopicIds.size + 
+                           parsed.changedPersonIds.size;
         
         ctx.showNotification(`Updated ${updateCount} items, deleted ${deleteCount}`, "info");
         return;

package/tui/src/util/yaml-context.ts

@@ -0,0 +1,66 @@
+import YAML from "yaml";
+import type { Message } from "../../../src/core/types.js";
+import { ContextStatus } from "../../../src/core/types.js";
+
+interface EditableMessage {
+  id: string;
+  role: "human" | "system";
+  timestamp: string;
+  context_status: ContextStatus;
+  _delete?: boolean;
+  content?: string;
+  silence_reason?: string;
+}
+
+function getContent(m: { content?: string; verbal_response?: string; action_response?: string }): string {
+  if (m.content) return m.content;
+  const parts: string[] = [];
+  if (m.action_response) parts.push(`_${m.action_response}_`);
+  if (m.verbal_response) parts.push(m.verbal_response);
+  return parts.join('\n\n');
+}
+
+export function contextToYAML(messages: Message[]): string {
+  const header = [
+    "# context_status: default | always | never",
+    "# _delete: true — permanently removes the message",
+    "# content | silence_reason",
+  ].join("\n");
+
+  const data: EditableMessage[] = messages.map((m) => ({
+    id: m.id,
+    role: m.role,
+    timestamp: m.timestamp,
+    context_status: m.context_status,
+    _delete: false,
+    content: getContent(m) || undefined,
+    silence_reason: m.silence_reason,
+  }));
+
+  return header + "\n" + YAML.stringify(data, { lineWidth: 0 });
+}
+
+export interface ContextYAMLResult {
+  messages: Array<{ id: string; context_status: ContextStatus }>;
+  deletedMessageIds: string[];
+}
+
+export function contextFromYAML(yamlContent: string): ContextYAMLResult {
+  const data = YAML.parse(yamlContent) as EditableMessage[];
+
+  const deletedMessageIds: string[] = [];
+  const messages: Array<{ id: string; context_status: ContextStatus }> = [];
+
+  for (const m of data ?? []) {
+    if (m._delete) {
+      deletedMessageIds.push(m.id);
+    } else {
+      const normalized = (m.context_status ?? 'default').toString().toLowerCase() as ContextStatus;
+      messages.push({ id: m.id, context_status: normalized });
+    }
+  }
+
+  return { messages, deletedMessageIds };
+}
+
+

package/tui/src/util/yaml-human.ts

@@ -0,0 +1,274 @@
+import YAML from "yaml";
+import type {
+  HumanEntity,
+  Fact,
+  Topic,
+  Person,
+  PersonIdentifier,
+} from "../../../src/core/types.js";
+import { BUILT_IN_FACT_NAMES } from "../../../src/core/constants/built-in-facts.js";
+import { BUILT_IN_IDENTIFIER_TYPES } from "../../../src/core/constants/built-in-identifier-types.js";
+
+interface EditableTopic extends Omit<Topic, 'persona_groups'> {
+  _delete?: boolean;
+  persona_groups?: Record<string, boolean>[];
+}
+
+interface EditableFact extends Omit<Fact, 'persona_groups'> {
+  _delete?: boolean;
+  persona_groups?: Record<string, boolean>[];
+}
+
+interface YAMLPersonIdentifier {
+  type: string;
+  value: string;
+  primary?: true;
+}
+
+interface EditablePersonYAML extends Omit<Person, 'identifiers' | 'persona_groups'> {
+  identifiers: YAMLPersonIdentifier[];
+  _delete?: boolean;
+  persona_groups?: Record<string, boolean>[];
+}
+
+interface EditableHumanData {
+  facts: EditableFact[];
+  topics: EditableTopic[];
+  people: EditablePersonYAML[];
+}
+
+type WithReadOnlyFields = {
+  learned_on?: string;
+  learned_by?: string;
+  validated_date?: string;
+  last_mentioned?: string;
+  last_updated: string;
+  last_changed_by?: string;
+};
+
+function readOnlyToEnd<T extends WithReadOnlyFields>(item: T): T {
+  const { learned_on, learned_by, validated_date, last_mentioned, last_updated, last_changed_by, ...rest } = item;
+  return { ...rest, learned_on, learned_by, validated_date, last_mentioned, last_updated, last_changed_by } as T;
+}
+
+function buildGroupCheckboxMap(itemGroups: string[], allGroups: string[]): Record<string, boolean>[] {
+  const activeSet = new Set(itemGroups);
+  return [...new Set([...allGroups, ...itemGroups])].map(g => ({ [g]: activeSet.has(g) }));
+}
+
+function toYAMLIdentifiers(identifiers: PersonIdentifier[], personaLookup?: Map<string, string>): YAMLPersonIdentifier[] {
+  return identifiers.map(({ type, value, is_primary }) => {
+    const resolvedValue = type === 'Ei Persona' ? (personaLookup?.get(value) ?? value) : value;
+    const entry: YAMLPersonIdentifier = { type, value: resolvedValue };
+    if (is_primary) entry.primary = true;
+    return entry;
+  });
+}
+
+function knownTypesComment(personaLookup?: Map<string, string>): string {
+  const lines = [`# Valid types: ${BUILT_IN_IDENTIFIER_TYPES.join(', ')}`];
+  if (personaLookup && personaLookup.size > 0) {
+    lines.push(`# Personas: ${Array.from(personaLookup.values()).join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+function parseGroupCheckboxMap(groups: Record<string, boolean>[] | undefined): string[] {
+  if (!groups) return [];
+  const result: string[] = [];
+  for (const record of groups) {
+    for (const [name, active] of Object.entries(record)) {
+      if (active) result.push(name);
+    }
+  }
+  return result;
+}
+
+export function humanToYAML(human: HumanEntity, personaLookup?: Map<string, string>, allGroups: string[] = []): string {
+  const data: EditableHumanData = {
+    facts: human.facts.map(f => { const { interested_personas: _ip, persona_groups, ...rest } = readOnlyToEnd(f); return { ...rest, persona_groups: buildGroupCheckboxMap(persona_groups ?? [], allGroups), _delete: false }; }),
+    topics: human.topics.map(t => { const { interested_personas: _ip, persona_groups, ...rest } = readOnlyToEnd(t); return { ...rest, persona_groups: buildGroupCheckboxMap(persona_groups ?? [], allGroups), _delete: false }; }),
+    people: human.people.map(p => {
+      const { identifiers, interested_personas: _ip, persona_groups, ...rest } = readOnlyToEnd(p);
+      return {
+        ...rest,
+        persona_groups: buildGroupCheckboxMap(persona_groups ?? [], allGroups),
+        identifiers: toYAMLIdentifiers(identifiers ?? [], personaLookup),
+        _delete: false as const,
+      };
+    }),
+  };
+
+  const personComment = knownTypesComment(personaLookup);
+
+  return YAML.stringify(data, {
+    lineWidth: 0,
+  })
+  .replace(/^(\s+)(learned_on: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(learned_by: )(.+)$/mg, (_, indent, key, val) => {
+    const trimmed = val.trim();
+    const displayName = personaLookup?.get(trimmed) ?? trimmed;
+    return `${indent}# [read-only] ${key}${displayName}`;
+  })
+  .replace(/^(\s+)(validated_date: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(last_mentioned: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(last_updated: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(last_changed_by: )(.+)$/mg, (_, indent, key, val) => {
+    const trimmed = val.trim();
+    const displayName = personaLookup?.get(trimmed) ?? trimmed;
+    return `${indent}# [read-only] ${key}${displayName}`;
+  })
+  .replace(/^(\s+)(identifiers:)/mg, (_, indent, _key) => {
+    return `${indent}${personComment}\n${indent}identifiers:`;
+  });
+}
+
+export interface HumanYAMLResult {
+  facts: Fact[];
+  topics: Topic[];
+  people: Person[];
+  deletedFactIds: string[];
+  deletedTopicIds: string[];
+  deletedPersonIds: string[];
+  changedFactIds: Set<string>;
+  changedTopicIds: Set<string>;
+  changedPersonIds: Set<string>;
+}
+
+function identifiersEqual(a: PersonIdentifier[] | undefined, b: PersonIdentifier[] | undefined): boolean {
+  const normalize = (ids: PersonIdentifier[] | undefined) =>
+    [...(ids ?? [])].sort((x, y) => `${x.type}:${x.value}`.localeCompare(`${y.type}:${y.value}`));
+  const na = normalize(a);
+  const nb = normalize(b);
+  if (na.length !== nb.length) return false;
+  return na.every((id, i) =>
+    id.type === nb[i].type &&
+    id.value === nb[i].value &&
+    Boolean(id.is_primary) === Boolean(nb[i].is_primary)
+  );
+}
+
+function groupsEqual(a: string[] | undefined, b: string[] | undefined): boolean {
+  const sa = [...(a ?? [])].sort();
+  const sb = [...(b ?? [])].sort();
+  if (sa.length !== sb.length) return false;
+  return sa.every((v, i) => v === sb[i]);
+}
+
+function factChanged(parsed: Fact, original: Fact): boolean {
+  const scalarFields: (keyof Fact)[] = [
+    'name', 'description', 'sentiment',
+  ];
+  for (const field of scalarFields) {
+    if (parsed[field] !== original[field]) return true;
+  }
+  return !groupsEqual(parsed.persona_groups, original.persona_groups);
+}
+
+function topicChanged(parsed: Topic, original: Topic): boolean {
+  const scalarFields: (keyof Topic)[] = [
+    'name', 'description', 'sentiment', 'exposure_current', 'exposure_desired', 'category',
+  ];
+  for (const field of scalarFields) {
+    if (parsed[field] !== original[field]) return true;
+  }
+  return !groupsEqual(parsed.persona_groups, original.persona_groups);
+}
+
+function personChanged(parsed: Person, original: Person): boolean {
+  const scalarFields: (keyof Person)[] = [
+    'name', 'description', 'sentiment', 'relationship',
+    'exposure_current', 'exposure_desired',
+  ];
+  for (const field of scalarFields) {
+    if (parsed[field] !== original[field]) return true;
+  }
+  if (!groupsEqual(parsed.persona_groups, original.persona_groups)) return true;
+  return !identifiersEqual(parsed.identifiers, original.identifiers);
+}
+
+export function humanFromYAML(yamlContent: string, original?: HumanEntity): HumanYAMLResult {
+  const stripped = yamlContent
+    .split('\n')
+    .filter(line => !/^\s*#\s*\[read-only\]/.test(line))
+    .join('\n');
+  const data = YAML.parse(stripped) as EditableHumanData;
+
+  const deletedFactIds: string[] = [];
+  const deletedTopicIds: string[] = [];
+  const deletedPersonIds: string[] = [];
+  const changedFactIds = new Set<string>();
+  const changedTopicIds = new Set<string>();
+  const changedPersonIds = new Set<string>();
+
+  const facts: Fact[] = [];
+  for (const f of data.facts ?? []) {
+    if (f._delete && !BUILT_IN_FACT_NAMES.has(f.name)) {
+      deletedFactIds.push(f.id);
+    } else {
+      const { _delete, persona_groups: groupMap, ...parsed } = f;
+      const originalFact = original?.facts.find(of => of.id === parsed.id);
+      const fact: Fact = originalFact
+        ? { ...originalFact, ...parsed, persona_groups: parseGroupCheckboxMap(groupMap) }
+        : { ...parsed, persona_groups: parseGroupCheckboxMap(groupMap) };
+      facts.push(fact);
+      if (!originalFact || factChanged(fact, originalFact)) {
+        if (fact.description && !originalFact?.validated_date) {
+          fact.validated_date = new Date().toISOString();
+        }
+        changedFactIds.add(fact.id);
+      }
+    }
+  }
+
+  const topics: Topic[] = [];
+  for (const t of data.topics ?? []) {
+    if (t._delete) {
+      deletedTopicIds.push(t.id);
+    } else {
+      const { _delete, persona_groups: groupMap, ...parsed } = t;
+      const originalTopic = original?.topics.find(ot => ot.id === parsed.id);
+      const topic: Topic = originalTopic
+        ? { ...originalTopic, ...parsed, persona_groups: parseGroupCheckboxMap(groupMap) }
+        : { ...parsed, persona_groups: parseGroupCheckboxMap(groupMap) };
+      topics.push(topic);
+      if (!originalTopic || topicChanged(topic, originalTopic)) {
+        changedTopicIds.add(topic.id);
+      }
+    }
+  }
+
+  const people: Person[] = [];
+  for (const p of data.people ?? []) {
+    if (p._delete) {
+      deletedPersonIds.push(p.id);
+    } else {
+      const { _delete, identifiers: yamlIdentifiers, persona_groups: groupMap, ...parsed } = p;
+      const identifiers: PersonIdentifier[] = (yamlIdentifiers ?? []).map(({ type, value, primary }) => ({
+        type,
+        value,
+        ...(primary ? { is_primary: true } : {}),
+      }));
+      const originalPerson = original?.people.find(op => op.id === parsed.id);
+      const person: Person = originalPerson
+        ? { ...originalPerson, ...parsed, identifiers, persona_groups: parseGroupCheckboxMap(groupMap) }
+        : { ...parsed, identifiers, persona_groups: parseGroupCheckboxMap(groupMap) };
+      people.push(person);
+      if (!originalPerson || personChanged(person, originalPerson)) {
+        changedPersonIds.add(person.id);
+      }
+    }
+  }
+
+  return {
+    facts,
+    topics,
+    people,
+    deletedFactIds,
+    deletedTopicIds,
+    deletedPersonIds,
+    changedFactIds,
+    changedTopicIds,
+    changedPersonIds,
+  };
+}