ei-tui 1.5.0 → 1.6.0

package/README.md

@@ -6,7 +6,7 @@ You can access the Web version at [ei.flare576.com](https://ei.flare576.com).
 
 You can run the local version via `bunx ei-tui` — no install needed, always current (see [### TUI](#tui) for details).
 
-If you're here to give your coding tools (OpenCode, Claude Code, Cursor) persistent memory, jump over to [TUI README.md](./tui/README.md) to learn how to get information _into_ Ei, and [CLI README.md](./src/cli/README.md) to get it back _out_.
+If you're here to give your coding tools (OpenCode, Claude Code, Cursor) persistent memory, jump over to [TUI README.md](./tui/README.md) to learn how to get information _into_ Ei, and [CLI README.md](./src/cli/README.md) to wire up automatic context injection so your agents receive relevant memory before every message — no tool calls required.
 
 ## What Does "Local First" Mean?
 
@@ -140,7 +140,7 @@ opencode:
 
 OpenCode saves sessions as JSON or SQLite (depending on version). Ei reads them, extracts context per-agent (each agent like Sisyphus gets its own persona), and keeps everything current as sessions accumulate.
 
-OpenCode can also *read* Ei's knowledge back out via the [CLI tool](src/cli/README.md) — making it a dynamic, perpetual RAG. That's why it always has context from your other projects.
+OpenCode can also *read* Ei's knowledge back out via the [CLI tool](src/cli/README.md). Run `ei --install` to wire up automatic context injection — relevant topics are injected before every message, and (with [Oh My OpenCode](https://github.com/code-yeongyu/oh-my-opencode)) each agent's Ei persona record is loaded into the system prompt at session start. The agent knows who it is *to you* before it reads your first message.
 
 #### Claude Code
 

package/package.json

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

package/src/cli/README.md

@@ -15,7 +15,7 @@ ei --recent                            # Most recently mentioned items (no query
 ei --persona "Beta" --recent           # Most recently mentioned items Beta has learned
 ei --id <id>                   # Look up entity by ID — or fetch a message by FQ ID
 echo <id> | ei --id            # Look up entity by ID from stdin
-ei --install                   # Register Ei with OpenCode, Claude Code, and Cursor
+ei --install                   # Wire Ei into Claude Code, Cursor, and OpenCode (MCP + hooks + persona plugin)
 ei mcp                         # Start the Ei MCP stdio server (for Cursor/Claude Desktop)
 ```
 
@@ -47,13 +47,17 @@ Quotes surfaced by `ei_search` include a `message_id` field in this format — p
 ei --install
 ```
 
-This registers Ei with Claude Code, Cursor, and OpenCode — MCP server config **and** context injection hooks so agents get Ei memory automatically without needing to call a tool:
+This registers Ei with Claude Code, Cursor, and OpenCode — MCP server config, context injection hooks, and (for OpenCode) a persona identity plugin so agents know who they are before the first message:
 
-| Tool | MCP | Context Hook |
-|------|-----|-------------|
-| **Claude Code** | `~/.claude.json` | `~/.claude/settings.json` (`UserPromptSubmit`) + `~/.claude/hooks/ei-inject.ts` |
-| **Cursor** | `~/.cursor/mcp.json` | `~/.cursor/hooks.json` (`beforeSubmitPrompt`) + `~/.cursor/hooks/ei-inject.sh` |
-| **OpenCode** | manual (see below) | Detected automatically via Oh My OpenCode compatibility layer (reads `~/.claude/settings.json`) |
+| Tool | MCP | Context Hook | Persona Plugin |
+|------|-----|-------------|----------------|
+| **Claude Code** | `~/.claude.json` | `~/.claude/settings.json` (`UserPromptSubmit`) + `~/.claude/hooks/ei-inject.ts` | — |
+| **Cursor** | `~/.cursor/mcp.json` | `~/.cursor/hooks.json` (`beforeSubmitPrompt`) + `~/.cursor/hooks/ei-inject.sh` | — |
+| **OpenCode** | manual (see below) | Via Oh My OpenCode compatibility layer (reads `~/.claude/settings.json`) | `~/.config/opencode/plugins/ei-persona.ts` |
+
+**Context hook**: fires before every message, searches Ei for topics relevant to what you just asked, injects them silently. No tool call required.
+
+**Persona plugin** (OpenCode + [Oh My OpenCode](https://github.com/code-yeongyu/oh-my-opencode) only): injects the agent's Ei relationship record directly into the system prompt at session start — traits, working style, shared context. The agent knows who it is *to you* before it reads a word of your message.
 
 **OpenCode MCP**: add manually to `~/.config/opencode/opencode.jsonc`:
 
@@ -82,73 +86,14 @@ Claude Code and Cursor call `ei mcp` to start the MCP stdio server. You can run
 ei mcp
 ```
 
-## Activating Ei in Your Agent
-
-`ei --install` handles both the technical wiring **and** context injection. After running it, your agent will automatically receive recent Ei memory before every message — no tool calls required.
-
-The snippets below are optional manual overrides if you want to customize the behavior or add targeted mid-session queries.
+## How Automatic Context Injection Works
 
-### OpenCode
+After `ei --install`, agents receive Ei context without any manual tool calls:
 
-If you're using [Oh My OpenCode](https://github.com/code-yeongyu/oh-my-opencode), the `UserPromptSubmit` hook installed by `ei --install` is picked up automatically via its Claude Code compatibility layer — no additional config needed.
-
-If you're running vanilla OpenCode without Oh My OpenCode, add to `~/.config/opencode/AGENTS.md`:
-
-```markdown
-Use the **ei** MCP to pull user context when the user references past work, mentions people
-or preferences, or asks "how did we do X." Call `ei_search` with a natural-language query.
-Use `ei --persona "Beta" "topic"` to scope results to what a specific persona has learned.
-```
+1. **Before each message** — the hook searches Ei using your prompt + recent conversation history as the query, then injects relevant topics into the conversation as `[Ei Memory Context]`. You won't see this in your chat view; the agent does.
+2. **At session start** (OpenCode + OMO only) — the persona plugin finds the agent's Ei persona record and appends it to the system prompt as `<ei-relationship>`. The agent knows its working style, traits, and shared history with you before the session begins.
 
-### Claude Code
-
-Add to `~/.claude/CLAUDE.md` (user-level) or `CLAUDE.md` at project root:
-
-```markdown
-At session start, use the **ei** MCP to pull user context: call `ei_search` with a
-natural-language query about the user's preferences, active projects, and workflow.
-A `persona` filter is available to scope results to what a specific persona has learned.
-Use `type: "personas"` to search for personas by name.
-
-Use Ei when the user references past decisions, mentions people or preferences, asks
-"how did we do X," or needs to look up a person by any name, handle, or account — people
-results include an `identifiers` array (GitHub username, Discord handle, email, nickname, etc.)
-covering all known accounts and aliases. Query again when they correct you or reference
-something from a previous session.
-```
-
-### Cursor
-
-Create `.cursor/rules/ei-mcp.mdc` in your project (or `~/.cursor/rules/` for user-level):
-
-```markdown
----
-description: When to use the Ei MCP for user memory and context
-alwaysApply: true
----
-# Ei MCP — User knowledge base
-
-The **ei** MCP (server `user-ei`) is a persistent knowledge base built from the user's
-conversations (facts, people, topics, quotes, personas).
-
-**Use it when:**
-- The user refers to past decisions, fixes, or "how we did X" and current chat/codebase
-  doesn't have that context.
-- You need the user's preferences, contacts, or project conventions (e.g. who to ask for
-  access, how something was fixed).
-- You need to look up a person by any name, handle, or account — people results include an
-  `identifiers` array (GitHub username, Discord handle, email, nickname, etc.) covering all
-  known accounts and aliases for that person.
-- The question is about the user personally (people, workflow, prior discussions) rather
-  than only code.
-
-**How to use:**
-1. Call `ei_search` (server `user-ei`) with a natural-language query (or omit query and use `recent: true` to browse); optionally filter by `type` (facts, people, topics, quotes, personas) or `persona` display_name.
-2. If you need the full record for any result, call `ei_lookup` with the entity `id` from step 1 — works for all types including personas.
-3. If a quote result has a `message_id`, call `ei_fetch_message` with that ID and optional `before`/`after` counts to read the original conversation with context.
-
-Prefer querying Ei before asking the user for context they may have already shared.
-```
+The `ei_search`, `ei_lookup`, and `ei_fetch_message` MCP tools are still available for targeted mid-session queries — use them when you want to look something up explicitly.
 
 ## MCP Tools Reference
 

package/src/cli.ts

@@ -90,8 +90,31 @@ Examples:
 
 async function installMcpClients(): Promise<void> {
   await installClaudeCode();
-  await installCursor();
-  await installOpenCodePlugin();
+
+  const home = process.env.HOME || "~";
+
+  const cursorDataDirs = [
+    join(home, "Library", "Application Support", "Cursor"),
+    join(home, ".config", "Cursor"),
+    join(home, "AppData", "Roaming", "Cursor"),
+  ];
+  const hasCursor = (await Promise.all(cursorDataDirs.map((p) => Bun.file(join(p, "User")).exists()))).some(Boolean);
+  if (hasCursor) {
+    await installCursor();
+  } else {
+    console.log(`ℹ️  Cursor not detected — skipping Cursor install.`);
+  }
+
+  const opencodeDir = join(home, ".config", "opencode");
+  const hasOpenCode = await Bun.file(join(opencodeDir, "opencode.jsonc")).exists() ||
+    await Bun.file(join(opencodeDir, "opencode.json")).exists() ||
+    await Bun.file(join(opencodeDir, "opencode.db")).exists();
+
+  if (hasOpenCode) {
+    await installOpenCodePlugin();
+  } else {
+    console.log(`ℹ️  OpenCode not detected — skipping OpenCode plugin install.`);
+  }
 }
 
 async function installClaudeCode(): Promise<void> {
@@ -155,10 +178,11 @@ import { $ } from "bun";
 
 const heading = \`
 ## Ei Memory Context
+*(The user cannot see this block. It is injected automatically before their message.)*
+*(If you reference anything from it, briefly explain where it came from — e.g. "Ei shows you've been working on X" — so the user isn't confused by knowledge that appeared from nowhere.)*
 
-Ei is a personal knowledge base built from coding sessions, Slack, documents, and conversations.
-The following topics MAY be relevant to your current task — use the \\\`ei_search\\\` and \\\`ei_lookup\\\`
-MCP tools for targeted queries.
+Ei is a personal knowledge base built from the user's coding sessions, Slack, documents, and conversations.
+The following topics MAY be relevant to your current task — use \\\`ei_search\\\` or \\\`ei_lookup\\\` for targeted queries.
 \`;
 
 const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
@@ -319,6 +343,127 @@ exit 0
 async function installOpenCodePlugin(): Promise<void> {
   const home = process.env.HOME || "~";
   const opencodeDir = join(home, ".config", "opencode");
+  const pluginsDir = join(opencodeDir, "plugins");
+  const pluginPath = join(pluginsDir, "ei-persona.ts");
+
+  await Bun.$`mkdir -p ${pluginsDir}`;
+
+  const pluginContent = `import { $ } from "bun"
+import { join } from "path"
+import { appendFileSync } from "fs"
+
+const sessionCache = new Map<string, string | null>()
+const sessionFetch = new Map<string, Promise<string | null>>()
+
+const logPath = join(process.env.EI_DATA_PATH ?? join(process.env.HOME ?? "~", ".local", "share", "ei"), "ei-persona-plugin.log")
+
+function log(msg: string) {
+  try {
+    appendFileSync(logPath, \`[\${new Date().toISOString()}] \${msg}\\n\`)
+  } catch {}
+}
+
+type PersonaTrait = { name: string; description: string; strength: number }
+type PersonaTopic = { name: string; perspective: string; approach: string; exposure_current: number }
+type PersonaResult = { display_name: string; base_prompt?: string; traits?: PersonaTrait[]; topics?: PersonaTopic[] }
+
+// Pulls the agent name from the system prompt. Handles OMO's multiple formats:
+//   You are "Sisyphus" - ...           (quoted, dash)
+//   You are "Sisyphus - Ultraworker"   (quoted, dash in name)
+//   You are Atlas - ...                (unquoted, dash)
+//   You are Hephaestus, ...            (unquoted, comma)
+export function extractAgentName(systemPrompt: string): string | null {
+  const clean = systemPrompt.replace(/[\\u200B-\\u200D\\uFEFF]/g, "")
+  const quoted = clean.match(/You are "([^"]+)"/)
+  if (quoted?.[1]) return quoted[1].trim()
+  const unquoted = clean.match(/You are ([A-Za-z][A-Za-z0-9]*)(?:\\s*[-—,]|\\s*$)/m)
+  if (unquoted?.[1]) return unquoted[1].trim()
+  return null
+}
+
+// Queries Ei for persona candidates and validates by name containment —
+// tolerates OMO renaming agents without requiring a hardcoded alias map.
+export async function resolveEiPersona(rawName: string): Promise<PersonaResult | null> {
+  try {
+    const out = await $\`bunx ei-tui@latest personas -n 5 \${rawName}\`.text()
+    const candidates = JSON.parse(out.trim()) as PersonaResult[]
+    if (!Array.isArray(candidates) || candidates.length === 0) return null
+    const rawLower = rawName.toLowerCase()
+    const match = candidates.find((p) => {
+      const nameLower = p.display_name.toLowerCase()
+      return rawLower.includes(nameLower) || nameLower.includes(rawLower)
+    })
+    return match ?? null
+  } catch {
+    return null
+  }
+}
+
+function buildEiRelationshipBlock(persona: PersonaResult): string {
+  const strongTraits = (persona.traits ?? [])
+    .filter((t) => t.strength >= 0.7)
+    .sort((a, b) => b.strength - a.strength)
+    .map((t) => \`**\${t.name}** (\${Math.round(t.strength * 100)}%): \${t.description}\`)
+    .join("\\n")
+  const sortedTopics = [...(persona.topics ?? [])]
+    .sort((a, b) => b.exposure_current - a.exposure_current)
+    .map((t) => \`**\${t.name}**: \${t.perspective} — \${t.approach}\`)
+    .join("\\n")
+  return [
+    "<ei-relationship>",
+    "## Ei: Relationship Context",
+    "",
+    persona.base_prompt ?? "",
+    "",
+    "### Working Style",
+    strongTraits || "(no traits above threshold)",
+    "",
+    "### Shared Context",
+    sortedTopics || "(no topics)",
+    "</ei-relationship>",
+  ].join("\\n")
+}
+
+export default async function EiPersonaPlugin() {
+  return {
+    name: "ei-persona",
+    "experimental.chat.system.transform": async (
+      input: { sessionID?: string; model: { id: string; providerID: string; [key: string]: unknown } },
+      output: { system: string[] },
+    ): Promise<void> => {
+      const rawName = extractAgentName(output.system[0] ?? "")
+      if (!rawName) return
+
+      const cacheKey = \`\${input.sessionID ?? "unknown"}:\${rawName}\`
+
+      if (sessionCache.has(cacheKey)) {
+        const cached = sessionCache.get(cacheKey) ?? null
+        if (cached !== null && !output.system[0].includes("<ei-relationship>"))
+          output.system[0] = output.system[0] + "\\n\\n" + cached
+        return
+      }
+
+      if (!sessionFetch.has(cacheKey)) {
+        sessionFetch.set(cacheKey, (async () => {
+          const persona = await resolveEiPersona(rawName)
+          if (!persona) return null
+          log(\`ei-persona: injecting \${persona.display_name}\`)
+          return buildEiRelationshipBlock(persona)
+        })())
+      }
+
+      const block = await sessionFetch.get(cacheKey)!
+      sessionCache.set(cacheKey, block)
+      if (block !== null && !output.system[0].includes("<ei-relationship>"))
+        output.system[0] = output.system[0] + "\\n\\n" + block
+    },
+  }
+}
+`;
+
+  await Bun.write(pluginPath, pluginContent);
+  console.log(`✓ Installed Ei persona plugin to ${pluginPath}`);
+
   const omoCandidates = [
     join(opencodeDir, "oh-my-opencode.json"),
     join(opencodeDir, "oh-my-opencode.jsonc"),
@@ -329,22 +474,18 @@ async function installOpenCodePlugin(): Promise<void> {
   ];
   const hasOmo = (await Promise.all(omoCandidates.map((p) => Bun.file(p).exists()))).some(Boolean);
 
-  if (hasOmo) {
-    console.log(`✓ Oh My OpenCode detected — UserPromptSubmit hook covers OpenCode automatically.`);
-    return;
-  }
-
-  console.log(`
-ℹ️  OpenCode detected without Oh My OpenCode.
-   The ~/.claude/settings.json UserPromptSubmit hook only fires in Claude Code.
-   For the same context injection in OpenCode, we recommend:
+  if (!hasOmo) {
+    console.log(`
+ℹ️  Oh My OpenCode not detected.
+   The Ei persona plugin is installed, but context injection (hook) requires OMO.
+   For full Ei integration in OpenCode, we recommend:
 
      bunx oh-my-opencode install
 
-   Oh My OpenCode is to OpenCode what oh-my-zsh is to zsh — you can run
-   without it, but you probably shouldn't. It also picks up the Ei hook
-   automatically via its Claude Code compatibility layer.
+   OMO picks up the Ei UserPromptSubmit hook automatically via its Claude Code
+   compatibility layer.
 `);
+  }
 }
 
 async function getRecentSessionMessages(

package/src/core/types/data-items.ts

@@ -75,8 +75,7 @@ export interface Person extends DataItemBase {
 }
 
 export interface Quote {
-  /** @deprecated Remove in v1.6 — use message_id for retrieval */
-  id: string;                    // UUID (use crypto.randomUUID())
+  id: string;                    // UUID — stable identity for CRUD operations (use crypto.randomUUID())
   message_id: string | null;     // FK to Message.id (nullable for manual quotes)
   data_item_ids: string[];       // FK[] to DataItemBase.id
   persona_groups: string[];      // Visibility groups

package/tui/README.md

@@ -39,7 +39,7 @@ Enable any or all three in `/settings`. They work independently and feed into th
 
 Sessions are processed oldest-first, one per queue cycle. On first run Ei works through your backlog gradually — it won't flood your LLM provider.
 
-OpenCode also supports reading Ei's extracted knowledge back out via the [CLI tool](../src/cli/README.md), giving it persistent memory across sessions.
+All three tools also support reading Ei's knowledge back out via the [CLI tool](../src/cli/README.md) — run `ei --install` to wire up automatic context injection (hooks + persona plugin) so your coding agents receive relevant Ei memory before every message without any manual tool calls.
 
 ## Slack Integration