ei-tui 1.6.2 → 1.6.4

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/src/integrations/slack/importer.ts

@@ -267,7 +267,7 @@ export async function importSlackChannel(opts: {
               ...updatedHuman.settings?.slack?.workspaces,
               [workspaceId]: {
                 ...workspaceConfig,
-                channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+                channels: { ...channelStates, [channelId]: updatedState },
               },
             },
           },

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.
 

package/tui/src/components/PromptInput.tsx

@@ -334,7 +334,11 @@ export function PromptInput() {
   registerEditorHandler(handleEditor);
 
   const getPlaceholder = () => {
-    if (activeRoomId() && humanRoomMessagePending()) return "Response Submitted - Press [Up] to recall";
+    if (activeRoomId() && humanRoomMessagePending()) {
+      const room = getRoom(activeRoomId()!);
+      if (room?.mode !== RoomMode.FreeForAll) return "Response Submitted - Press [Up] to recall";
+      return "Response Submitted";
+    }
     if (!activePersonaId()) return "Select a persona...";
     return "Type your message... (Enter to send, Ctrl+E for editor)";
   };

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

@@ -8,6 +8,7 @@ import type {
 import type { ClaudeCodeSettings } from "../../../src/integrations/claude-code/types.js";
 import type { CursorSettings } from "../../../src/integrations/cursor/types.js";
 import type { CodexSettings } from "../../../src/integrations/codex/types.js";
+import type { PiSettings } from "../../../src/integrations/pi/types.js";
 import type { SlackSettings, SlackAuth } from "../../../src/integrations/slack/types.js";
 import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
 import { parseDuration, formatDuration } from "./duration.js";
@@ -55,6 +56,13 @@ interface EditableSettingsData {
     extraction_point?: string | null;
     extraction_model?: string | null;
   };
+  pi?: {
+    integration?: boolean | null;
+    polling_interval_ms?: string | null;
+    last_sync?: string | null;
+    extraction_point?: string | null;
+    extraction_model?: string | null;
+  };
   slack?: {
     polling_interval_ms?: string | null;
     workspaces?: Record<string, {
@@ -127,6 +135,13 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
       last_sync: settings?.codex?.last_sync ?? null,
       extraction_point: settings?.codex?.extraction_point ?? null,
     },
+    pi: {
+      integration: settings?.pi?.integration ?? false,
+      polling_interval_ms: formatDuration(settings?.pi?.polling_interval_ms ?? 60000),
+      extraction_model: guidToDisplay(settings?.pi?.extraction_model) ?? 'default',
+      last_sync: settings?.pi?.last_sync ?? null,
+      extraction_point: settings?.pi?.extraction_point ?? null,
+    },
     slack: {
       polling_interval_ms: formatDuration(settings?.slack?.polling_interval_ms ?? 60000),
       workspaces: Object.fromEntries(
@@ -231,6 +246,18 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     };
   }
 
+  let pi: PiSettings | undefined;
+  if (data.pi) {
+    pi = {
+      integration: nullToUndefined(data.pi.integration),
+      polling_interval_ms: parseMsDuration(data.pi.polling_interval_ms, 60000),
+      last_sync: original?.pi?.last_sync,
+      extraction_point: original?.pi?.extraction_point,
+      processed_sessions: original?.pi?.processed_sessions,
+      extraction_model: displayToGuid(data.pi.extraction_model),
+    };
+  }
+
   let slack: SlackSettings | undefined;
   if (data.slack) {
     const parsedWorkspaces: SlackSettings["workspaces"] = {};
@@ -277,6 +304,7 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     claudeCode,
     cursor,
     codex,
+    pi,
     slack,
     backup,
   };