ei-tui 1.6.2 → 1.6.3

package/src/integrations/pi/importer.ts

@@ -0,0 +1,235 @@
+import type { StateManager } from "../../core/state-manager.js";
+import type { Ei_Interface, Message, PersonaEntity, PersonaTrait } from "../../core/types.js";
+import { DEFAULT_SEED_TRAITS } from "../../core/constants/seed-traits.js";
+import {
+  queueAllScans,
+  type ExtractionContext,
+} from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
+import { qualifyPiMessage } from "../../core/utils/message-id.js";
+import { convertToEiMessage, convertToPreMarkedEiMessage } from "../shared/message-converter.js";
+import { getMachineId } from "../machine-id.js";
+import { isProcessRunning } from "../process-check.js";
+import { PiReader } from "./reader.js";
+import {
+  PI_PERSONA_NAME,
+  type PiSession,
+  type IPiReader,
+} from "./types.js";
+import { MIN_SESSION_AGE_MS, TWELVE_HOURS_MS } from "../constants.js";
+
+export interface PiImportResult {
+  sessionsProcessed: number;
+  messagesImported: number;
+  personaCreated: boolean;
+  extractionScansQueued: number;
+}
+
+export interface PiImporterOptions {
+  stateManager: StateManager;
+  interface?: Ei_Interface;
+  reader?: IPiReader;
+  signal?: AbortSignal;
+}
+
+const PI_GROUP = "Pi";
+
+const qualify = qualifyPiMessage;
+
+function ensurePiPersona(
+  stateManager: StateManager,
+  eiInterface?: Ei_Interface
+): PersonaEntity {
+  const existing = stateManager.persona_getByName(PI_PERSONA_NAME);
+  if (existing) return existing;
+
+  const now = new Date().toISOString();
+  const seedTraits: PersonaTrait[] = DEFAULT_SEED_TRAITS.map((t) => ({
+    id: crypto.randomUUID(),
+    name: t.name,
+    description: t.description,
+    sentiment: t.sentiment,
+    strength: t.strength,
+    last_updated: now,
+  }));
+
+  const persona: PersonaEntity = {
+    id: crypto.randomUUID(),
+    display_name: PI_PERSONA_NAME,
+    entity: "system",
+    aliases: ["pi", "pi coding agent", "omp", "oh-my-pi"],
+    short_description: "Pi - minimal terminal coding harness",
+    long_description:
+      "Pi is a minimal terminal coding harness. Covers both vanilla Pi (earendil-works/pi) and the oh-my-pi fork (omp), which share the same JSONL session format.",
+    group_primary: PI_GROUP,
+    groups_visible: [PI_GROUP],
+    traits: seedTraits,
+    topics: [],
+    is_paused: false,
+    is_archived: false,
+    is_static: false,
+    heartbeat_delay_ms: TWELVE_HOURS_MS,
+    last_heartbeat: now,
+    last_updated: now,
+  };
+
+  stateManager.persona_add(persona);
+  eiInterface?.onPersonaAdded?.();
+  return persona;
+}
+
+function updateProcessedState(stateManager: StateManager, session: PiSession): void {
+  const human = stateManager.getHuman();
+  const lastMessageMs = new Date(session.lastMessageAt).getTime();
+  const extractionPoint = human.settings?.pi?.extraction_point;
+  const currentPointMs = extractionPoint ? new Date(extractionPoint).getTime() : 0;
+  const newPointMs = Math.max(currentPointMs, lastMessageMs);
+
+  const processedSessions = {
+    ...(human.settings?.pi?.processed_sessions ?? {}),
+    [session.id]: new Date().toISOString(),
+  };
+
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      pi: {
+        ...human.settings?.pi,
+        extraction_point: new Date(newPointMs).toISOString(),
+        processed_sessions: processedSessions,
+      },
+    },
+  });
+}
+
+async function isPiRunning(): Promise<boolean> {
+  return (
+    (await isProcessRunning("pi")) ||
+    (await isProcessRunning("omp"))
+  );
+}
+
+export async function importPiSessions(options: PiImporterOptions): Promise<PiImportResult> {
+  const { stateManager, interface: eiInterface, signal } = options;
+  const reader = options.reader ?? new PiReader();
+
+  const result: PiImportResult = {
+    sessionsProcessed: 0,
+    messagesImported: 0,
+    personaCreated: false,
+    extractionScansQueued: 0,
+  };
+
+  const allSessions = await reader.getSessions();
+  if (signal?.aborted) return result;
+
+  const human = stateManager.getHuman();
+  const processedSessions = human.settings?.pi?.processed_sessions ?? {};
+  const now = Date.now();
+  const toolRunning = await isPiRunning();
+
+  let targetSession: PiSession | null = null;
+
+  for (const session of allSessions) {
+    const sessionLastMs = new Date(session.lastMessageAt).getTime();
+    const ageMs = now - sessionLastMs;
+
+    if (ageMs < MIN_SESSION_AGE_MS && toolRunning) continue;
+
+    const lastImported = processedSessions[session.id];
+    if (lastImported && sessionLastMs <= new Date(lastImported).getTime()) continue;
+
+    targetSession = session;
+    break;
+  }
+
+  if (!targetSession) {
+    console.log("[Pi] All sessions processed, nothing new to import");
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  console.log(
+    `[Pi] Processing session: "${targetSession.title}" ` +
+      `(last message: ${targetSession.lastMessageAt})`
+  );
+
+  const messages = targetSession.messages;
+  if (messages.length === 0) {
+    updateProcessedState(stateManager, targetSession);
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  const personaExistedBefore = stateManager.persona_getByName(PI_PERSONA_NAME) !== null;
+  const persona = ensurePiPersona(stateManager, eiInterface);
+  result.personaCreated = !personaExistedBefore;
+
+  if (!personaExistedBefore) {
+    stateManager.persona_archive(persona.id);
+  } else {
+    const existingMsgs = stateManager.messages_get(persona.id);
+    const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+    if (externalIds.length > 0) {
+      stateManager.messages_remove(persona.id, externalIds);
+    }
+  }
+
+  const cutoffIso = processedSessions[targetSession.id] ?? null;
+  const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+  const toAnalyze: Message[] = [];
+
+  for (const msg of messages) {
+    const msgMs = new Date(msg.timestamp).getTime();
+    const isOld = cutoffMs !== null && msgMs < cutoffMs;
+    const eiMsg = isOld
+      ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+      : convertToEiMessage(msg, targetSession.id, qualify);
+
+    stateManager.messages_append(persona.id, eiMsg);
+    result.messagesImported++;
+    if (!isOld) toAnalyze.push(eiMsg);
+  }
+
+  stateManager.messages_sort(persona.id);
+  eiInterface?.onMessageAdded?.(persona.id);
+
+  if (toAnalyze.length > 0 && !signal?.aborted) {
+    const allInState = stateManager.messages_get(persona.id);
+    const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+    const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+    const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+    const context: ExtractionContext = {
+      personaId: persona.id,
+      channelDisplayName: persona.display_name,
+      messages_context: contextMsgs,
+      messages_analyze: toAnalyze,
+      sources: [`pi:${getMachineId()}:${targetSession.id}`],
+    };
+
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+    queueAllScans(context, stateManager, {
+      extraction_model: human.settings?.pi?.extraction_model,
+      external_filter: "only",
+    });
+    result.extractionScansQueued += 4;
+  }
+
+  result.sessionsProcessed = 1;
+  updateProcessedState(stateManager, targetSession);
+
+  console.log(
+    `[Pi] Session complete: ${result.messagesImported} messages imported, ` +
+      `${result.extractionScansQueued} extraction scans queued`
+  );
+
+  return result;
+}

package/src/integrations/pi/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./reader.js";
+export * from "./importer.js";

package/src/integrations/pi/reader.ts

@@ -0,0 +1,247 @@
+import type {
+  IPiReader,
+  PiSession,
+  PiMessage,
+  PiMessageWindow,
+  PiMessageEntry,
+  PiGenericEntry,
+  PiContentBlock,
+} from "./types.js";
+
+const isBrowser = typeof document !== "undefined";
+
+let _join: typeof import("path").join;
+let _readdir: typeof import("fs/promises").readdir;
+let _readFile: typeof import("fs/promises").readFile;
+let _existsSync: typeof import("fs").existsSync;
+let _nodeModulesLoaded = false;
+
+async function ensureNodeModules(): Promise<boolean> {
+  if (isBrowser) return false;
+  if (_nodeModulesLoaded) return true;
+
+  const PATH_MODULE = "path";
+  const FS_MODULE = "fs/promises";
+  const FS_SYNC_MODULE = "fs";
+
+  const pathMod = await import(/* @vite-ignore */ PATH_MODULE);
+  const fsMod = await import(/* @vite-ignore */ FS_MODULE);
+  const fsSyncMod = await import(/* @vite-ignore */ FS_SYNC_MODULE);
+
+  _join = pathMod.join;
+  _readdir = fsMod.readdir;
+  _readFile = fsMod.readFile;
+  _existsSync = fsSyncMod.existsSync;
+  _nodeModulesLoaded = true;
+  return true;
+}
+
+/**
+ * Pi encodes the cwd into the session directory name by replacing every "/"
+ * with "--". The root "/" becomes an empty leading segment, so paths end up
+ * looking like "--Users--flare576--Projects--Personal--ei--".
+ * This reverses that encoding.
+ */
+function decodeCwd(dirName: string): string {
+  return dirName.replace(/--/g, "/") || "/";
+}
+
+function titleFromCwd(cwd: string): string {
+  if (!cwd) return "Unknown";
+  const parts = cwd.replace(/\\/g, "/").split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? cwd;
+}
+
+/**
+ * Extracts the session UUID from a Pi session filename.
+ * Filename format: "2026-05-20T14-57-03-205Z_019e45e3-e2e5-7174-8165-da221c147ebb.jsonl"
+ */
+function uuidFromFilename(filename: string): string | null {
+  const base = filename.replace(/\.jsonl$/, "");
+  const underscoreIdx = base.indexOf("_");
+  if (underscoreIdx === -1) return null;
+  return base.slice(underscoreIdx + 1);
+}
+
+function extractAssistantText(content: PiContentBlock[] | string | undefined): string {
+  if (!content) return "";
+  if (typeof content === "string") return content.trim();
+  return content
+    .filter((b): b is { type: "text"; text: string } => b.type === "text")
+    .map((b) => b.text)
+    .join("\n\n")
+    .trim();
+}
+
+function isPiMessageEntry(entry: PiGenericEntry): entry is PiMessageEntry {
+  return entry.type === "message" && typeof entry.message === "object" && entry.message !== null;
+}
+
+export class PiReader implements IPiReader {
+  private readonly sessionsRoots: string[];
+
+  constructor(sessionsRoots?: string[]) {
+    this.sessionsRoots = sessionsRoots ?? [];
+  }
+
+  async isAvailable(): Promise<boolean> {
+    if (!(await ensureNodeModules())) return false;
+    const roots = this.sessionsRoots.length > 0 ? this.sessionsRoots : getDefaultSessionsRoots();
+    return roots.some((r) => _existsSync(r));
+  }
+
+  async getSessions(): Promise<PiSession[]> {
+    if (!(await ensureNodeModules())) return [];
+
+    const roots = this.sessionsRoots.length > 0 ? this.sessionsRoots : getDefaultSessionsRoots();
+    const sessions: PiSession[] = [];
+
+    for (const root of roots) {
+      if (!_existsSync(root)) continue;
+
+      let cwdDirs: string[];
+      try {
+        cwdDirs = await _readdir(root);
+      } catch {
+        continue;
+      }
+
+      for (const cwdDir of cwdDirs) {
+        if (cwdDir.startsWith(".")) continue;
+        const cwdPath = _join(root, cwdDir);
+        const cwd = decodeCwd(cwdDir);
+
+        let sessionFiles: string[];
+        try {
+          sessionFiles = await _readdir(cwdPath);
+        } catch {
+          continue;
+        }
+
+        for (const filename of sessionFiles) {
+          if (!filename.endsWith(".jsonl")) continue;
+
+          const uuid = uuidFromFilename(filename);
+          if (!uuid) continue;
+
+          const filePath = _join(cwdPath, filename);
+          const session = await this.parseSession(uuid, cwd, filePath);
+          if (session) sessions.push(session);
+        }
+      }
+    }
+
+    return sessions.sort(
+      (a, b) => new Date(a.firstMessageAt).getTime() - new Date(b.firstMessageAt).getTime()
+    );
+  }
+
+  async getMessageById(
+    sessionId: string,
+    messageId: string,
+    before = 0,
+    after = 0
+  ): Promise<PiMessageWindow | null> {
+    if (!(await ensureNodeModules())) return null;
+
+    const allSessions = await this.getSessions();
+    const session = allSessions.find((s) => s.id === sessionId);
+    if (!session) return null;
+
+    const msgs = session.messages;
+    const idx = msgs.findIndex((m) => m.id === messageId || m.id.endsWith(`/${messageId}`));
+    if (idx === -1) return null;
+
+    return {
+      message: msgs[idx],
+      before: msgs.slice(Math.max(0, idx - before), idx),
+      after: msgs.slice(idx + 1, idx + 1 + after),
+      session,
+    };
+  }
+
+  private async parseSession(
+    uuid: string,
+    cwd: string,
+    filePath: string
+  ): Promise<PiSession | null> {
+    const entries = await this.readJsonl(filePath);
+    const messages: PiMessage[] = [];
+    let firstTs: string | null = null;
+    let lastTs: string | null = null;
+
+    for (const entry of entries) {
+      if (!isPiMessageEntry(entry)) continue;
+
+      const role = entry.message.role;
+      if (role !== "user" && role !== "assistant") continue;
+
+      let content = "";
+      if (role === "user") {
+        content = typeof entry.message.content === "string"
+          ? entry.message.content.trim()
+          : extractAssistantText(entry.message.content);
+      } else {
+        content = extractAssistantText(entry.message.content);
+      }
+
+      if (!content) continue;
+
+      const ts = entry.timestamp;
+      if (ts) {
+        if (!firstTs || ts < firstTs) firstTs = ts;
+        if (!lastTs || ts > lastTs) lastTs = ts;
+      }
+
+      messages.push({
+        id: `${uuid}/${entry.id}`,
+        sessionId: uuid,
+        role,
+        content,
+        timestamp: ts ?? new Date(0).toISOString(),
+      });
+    }
+
+    if (!firstTs || !lastTs || messages.length === 0) return null;
+
+    messages.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+
+    return {
+      id: uuid,
+      title: titleFromCwd(cwd),
+      cwd,
+      firstMessageAt: firstTs,
+      lastMessageAt: lastTs,
+      messages,
+    };
+  }
+
+  private async readJsonl(filePath: string): Promise<PiGenericEntry[]> {
+    let text: string;
+    try {
+      text = await _readFile(filePath, "utf-8");
+    } catch {
+      return [];
+    }
+
+    const entries: PiGenericEntry[] = [];
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        entries.push(JSON.parse(trimmed) as PiGenericEntry);
+      } catch {
+        // skip malformed lines
+      }
+    }
+    return entries;
+  }
+}
+
+function getDefaultSessionsRoots(): string[] {
+  const home = process.env.HOME ?? "~";
+  return [
+    _join(home, ".pi", "agent", "sessions"),
+    _join(home, ".omp", "agent", "sessions"),
+  ];
+}

package/src/integrations/pi/types.ts

@@ -0,0 +1,151 @@
+/**
+ * Pi Integration Types
+ *
+ * Pi (pi.dev / earendil-works/pi and the oh-my-pi fork) stores sessions as
+ * JSONL files under ~/.pi/agent/sessions/ (pi) or ~/.omp/agent/sessions/ (omp).
+ *
+ * Directory layout:
+ *   <sessionsRoot>/
+ *     <cwd-encoded>/          # cwd with "/" replaced by "--"
+ *       <iso-ts>_<uuid>.jsonl # one file per session
+ *
+ * Each line in a session file is a JSON entry with a `type` field.
+ * We only care about `type: "message"` entries.
+ */
+
+// ============================================================================
+// Reader Interface
+// ============================================================================
+
+export interface PiMessageWindow {
+  message: PiMessage;
+  before: PiMessage[];
+  after: PiMessage[];
+  session: PiSession;
+}
+
+export interface IPiReader {
+  getSessions(): Promise<PiSession[]>;
+  getMessageById(
+    sessionId: string,
+    messageId: string,
+    before?: number,
+    after?: number
+  ): Promise<PiMessageWindow | null>;
+  isAvailable(): Promise<boolean>;
+}
+
+// ============================================================================
+// Raw JSONL Entry Types
+// ============================================================================
+
+/**
+ * A `type: "message"` entry in a Pi session JSONL file.
+ * Other entry types (model-change, thinking-level, label, compaction,
+ * branch-summary, extension) are skipped during import.
+ */
+export interface PiMessageEntry {
+  type: "message";
+  id: string;
+  parentId?: string;
+  timestamp: string;
+  message: PiMessagePayload;
+  [key: string]: unknown;
+}
+
+export interface PiMessagePayload {
+  role: "user" | "assistant" | "toolResult" | "custom";
+  content?: PiContentBlock[] | string;
+  // assistant-only fields
+  model?: string;
+  provider?: string;
+  stopReason?: string;
+  usage?: unknown;
+  // toolResult-only fields
+  toolName?: string;
+  toolCallId?: string;
+  isError?: boolean;
+  // custom (extension-injected) fields
+  customType?: string;
+  display?: boolean;
+}
+
+export type PiContentBlock =
+  | { type: "text"; text: string }
+  | { type: "thinking"; thinking: string; thinkingSignature?: string }
+  | { type: "toolCall"; id: string; name: string; arguments: unknown }
+  | { type: "image"; source: unknown }
+  | { type: string; [key: string]: unknown };
+
+/** Union of all entry types we may encounter (we skip non-message ones). */
+export interface PiGenericEntry {
+  type: string;
+  id?: string;
+  parentId?: string;
+  timestamp?: string;
+  [key: string]: unknown;
+}
+
+// ============================================================================
+// Cleaned Session / Message Types
+// ============================================================================
+
+export interface PiSession {
+  /** Full UUID from filename, e.g. "019e45e3-e2e5-7174-8165-da221c147ebb" */
+  id: string;
+  /** Human-readable title derived from the cwd directory name */
+  title: string;
+  /** Decoded working directory path */
+  cwd: string;
+  /** ISO timestamp of the earliest message */
+  firstMessageAt: string;
+  /** ISO timestamp of the most recent message */
+  lastMessageAt: string;
+  /** All user/assistant messages, sorted oldest-first */
+  messages: PiMessage[];
+}
+
+export interface PiMessage {
+  /** Synthetic stable id: "<sessionUuid>/<entryId>", e.g. "019e45e3.../e5c48339" */
+  id: string;
+  sessionId: string;
+  role: "user" | "assistant";
+  content: string;
+  timestamp: string;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+/** Single persona name for all Pi/OMP sessions on a machine */
+export const PI_PERSONA_NAME = "Pi";
+
+/** Topic groups assigned to Pi session topics */
+export const PI_TOPIC_GROUPS = ["General", "Coding", "Pi"];
+
+/**
+ * Minimum session age before import, while the tool is running.
+ * Mirrors the Claude Code / Codex 20-minute rule so active sessions settle.
+ */
+export { MIN_SESSION_AGE_MS } from "../constants.js";
+
+// ============================================================================
+// Human Settings Shape
+// ============================================================================
+
+/**
+ * Stored under human.settings.pi
+ *
+ * WARNING: ADDING A NEW FIELD HERE?
+ * If it is runtime-managed (not user-editable), also preserve it in
+ * settingsFromYAML() in tui/src/util/yaml-settings.ts or /settings will wipe it.
+ */
+export interface PiSettings {
+  integration?: boolean;
+  polling_interval_ms?: number;
+  extraction_model?: string;
+  last_sync?: string;
+  extraction_point?: string;
+  processed_sessions?: Record<string, string>;
+}

package/src/integrations/shared/message-converter.ts

@@ -0,0 +1,41 @@
+import type { ContextStatus, Message } from "../../core/types.js";
+import { getMachineId } from "../machine-id.js";
+
+export type QualifyFn = (machine: string, sessionId: string, nativeId: string) => string;
+
+export interface ConvertibleMessage {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  timestamp: string;
+}
+
+export function convertToEiMessage(
+  msg: ConvertibleMessage,
+  sessionId: string,
+  qualify: QualifyFn
+): Message {
+  return {
+    id: qualify(getMachineId(), sessionId, msg.id),
+    role: msg.role === "user" ? "human" : "system",
+    content: msg.content,
+    timestamp: msg.timestamp,
+    read: true,
+    context_status: "default" as ContextStatus,
+    external: true,
+  };
+}
+
+export function convertToPreMarkedEiMessage(
+  msg: ConvertibleMessage,
+  sessionId: string,
+  qualify: QualifyFn
+): Message {
+  return {
+    ...convertToEiMessage(msg, sessionId, qualify),
+    f: true,
+    t: true,
+    p: true,
+    e: true,
+  };
+}

package/tui/README.md

@@ -37,6 +37,7 @@ Enable any or all four in `/settings`. They work independently and feed into the
 | Claude Code | `claudeCode.integration: true` | `~/.claude/projects/` (JSONL files) |
 | Cursor | `cursor.integration: true` | `~/Library/Application Support/Cursor/User/` (macOS)<br>`%APPDATA%\Cursor\User\` (Windows)<br>`~/.config/Cursor/User/` (Linux) |
 | Codex | `codex.integration: true` | `~/.codex/state_*.sqlite` + `~/.codex/sessions/` rollout JSONL files |
+| Pi / OMP | `pi.integration: true` | `~/.pi/agent/sessions/` (Pi) or `~/.omp/agent/sessions/` (oh-my-pi) — JSONL files |
 
 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.