ei-tui 0.1.3

package/src/integrations/opencode/index.ts

@@ -0,0 +1,16 @@
+export { JsonReader } from "./json-reader.js";
+// SqliteReader not exported directly - uses bun:sqlite which breaks Vite builds
+// Use createOpenCodeReader() factory instead, which dynamically imports when available
+export { createOpenCodeReader } from "./reader-factory.js";
+export { importOpenCodeSessions } from "./importer.js";
+export type { ImportResult, OpenCodeImporterOptions } from "./importer.js";
+export type {
+  IOpenCodeReader,
+  OpenCodeSession,
+  OpenCodeSessionRaw,
+  OpenCodeMessage,
+  OpenCodeMessageRaw,
+  OpenCodePartRaw,
+  OpenCodeAgent,
+} from "./types.js";
+export { BUILTIN_AGENTS } from "./types.js";

package/src/integrations/opencode/json-reader.ts

@@ -0,0 +1,304 @@
+import type {
+  IOpenCodeReader,
+  OpenCodeSession,
+  OpenCodeSessionRaw,
+  OpenCodeMessage,
+  OpenCodeMessageRaw,
+  OpenCodePartRaw,
+  OpenCodeAgent,
+} from "./types.js";
+import { BUILTIN_AGENTS } from "./types.js";
+
+// OpenTUI polyfills window but not document - check document for real browser
+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 _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 pathMod = await import(/* @vite-ignore */ PATH_MODULE);
+  const fsMod = await import(/* @vite-ignore */ FS_MODULE);
+  
+  _join = pathMod.join;
+  _readdir = fsMod.readdir;
+  _readFile = fsMod.readFile;
+  _nodeModulesLoaded = true;
+  return true;
+}
+
+function getDefaultStoragePath(): string {
+  if (!_join) return "";
+  return _join(
+    process.env.HOME || "~",
+    ".local",
+    "share",
+    "opencode",
+    "storage"
+  );
+}
+
+export class JsonReader implements IOpenCodeReader {
+  private storagePath: string | null = null;
+  private readonly configuredPath?: string;
+
+  constructor(storagePath?: string) {
+    this.configuredPath = storagePath;
+  }
+
+  private async init(): Promise<boolean> {
+    if (!(await ensureNodeModules())) return false;
+    if (!this.storagePath) {
+      this.storagePath = this.configuredPath || getDefaultStoragePath();
+    }
+    return true;
+  }
+
+  async getSessionsUpdatedSince(since: Date): Promise<OpenCodeSession[]> {
+    if (!(await this.init())) return [];
+    
+    const sinceMs = since.getTime();
+    const sessions: OpenCodeSession[] = [];
+    const sessionDir = _join(this.storagePath!, "session");
+
+    let projectDirs: string[];
+    try {
+      projectDirs = await _readdir(sessionDir);
+    } catch {
+      return [];
+    }
+
+    for (const projectHash of projectDirs) {
+      if (projectHash.startsWith(".")) continue;
+
+      const projectPath = _join(sessionDir, projectHash);
+      let sessionFiles: string[];
+      try {
+        sessionFiles = await _readdir(projectPath);
+      } catch {
+        continue;
+      }
+
+      for (const fileName of sessionFiles) {
+        if (!fileName.endsWith(".json")) continue;
+
+        const filePath = _join(projectPath, fileName);
+        const raw = await this.readJsonFile<OpenCodeSessionRaw>(filePath);
+        if (!raw) continue;
+
+        if (raw.time.updated > sinceMs) {
+          sessions.push({
+            id: raw.id,
+            title: raw.title,
+            directory: raw.directory,
+            projectId: raw.projectID,
+            parentId: raw.parentID,
+            time: {
+              created: raw.time.created,
+              updated: raw.time.updated,
+            },
+          });
+        }
+      }
+    }
+
+    return sessions.sort((a, b) => b.time.updated - a.time.updated);
+  }
+
+  async getSessionsInRange(from: Date, to: Date): Promise<OpenCodeSession[]> {
+    if (!(await this.init())) return [];
+
+    const fromMs = from.getTime();
+    const toMs = to.getTime();
+    const sessions: OpenCodeSession[] = [];
+    const sessionDir = _join(this.storagePath!, "session");
+
+    let projectDirs: string[];
+    try {
+      projectDirs = await _readdir(sessionDir);
+    } catch {
+      return [];
+    }
+
+    for (const projectHash of projectDirs) {
+      if (projectHash.startsWith(".")) continue;
+
+      const projectPath = _join(sessionDir, projectHash);
+      let sessionFiles: string[];
+      try {
+        sessionFiles = await _readdir(projectPath);
+      } catch {
+        continue;
+      }
+
+      for (const fileName of sessionFiles) {
+        if (!fileName.endsWith(".json")) continue;
+
+        const filePath = _join(projectPath, fileName);
+        const raw = await this.readJsonFile<OpenCodeSessionRaw>(filePath);
+        if (!raw) continue;
+
+        if (raw.time.updated > fromMs && raw.time.updated <= toMs && !raw.parentID) {
+          sessions.push({
+            id: raw.id,
+            title: raw.title,
+            directory: raw.directory,
+            projectId: raw.projectID,
+            parentId: raw.parentID,
+            time: {
+              created: raw.time.created,
+              updated: raw.time.updated,
+            },
+          });
+        }
+      }
+    }
+
+    return sessions.sort((a, b) => a.time.updated - b.time.updated);
+  }
+
+  async getMessagesForSession(
+    sessionId: string,
+    since?: Date
+  ): Promise<OpenCodeMessage[]> {
+    if (!(await this.init())) return [];
+    
+    const sinceMs = since?.getTime() ?? 0;
+    const messages: OpenCodeMessage[] = [];
+    const messageDir = _join(this.storagePath!, "message", sessionId);
+
+    let messageFiles: string[];
+    try {
+      messageFiles = await _readdir(messageDir);
+    } catch {
+      return [];
+    }
+
+    for (const fileName of messageFiles) {
+      if (!fileName.endsWith(".json")) continue;
+
+      const filePath = _join(messageDir, fileName);
+      const raw = await this.readJsonFile<OpenCodeMessageRaw>(filePath);
+      if (!raw) continue;
+
+      if (raw.time.created <= sinceMs) continue;
+
+      const content = await this.getMessageContent(raw.id);
+      if (!content) continue;
+
+      messages.push({
+        id: raw.id,
+        sessionId: raw.sessionID,
+        role: raw.role,
+        agent: (raw.agent || "build").toLowerCase(),
+        content,
+        timestamp: new Date(raw.time.created).toISOString(),
+      });
+    }
+
+    return messages.sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+  }
+
+  async getAgentInfo(agentName: string): Promise<OpenCodeAgent | null> {
+    const normalized = agentName.toLowerCase();
+    if (BUILTIN_AGENTS[normalized]) {
+      return BUILTIN_AGENTS[normalized];
+    }
+    return {
+      name: agentName,
+      description: "OpenCode coding agent",
+    };
+  }
+
+  async getAllUniqueAgents(sessionId: string): Promise<string[]> {
+    const messages = await this.getMessagesForSession(sessionId);
+    const agents = new Set<string>();
+    for (const msg of messages) {
+      agents.add(msg.agent);
+    }
+    return Array.from(agents);
+  }
+
+  async getFirstAgent(sessionId: string): Promise<string | null> {
+    if (!(await this.init())) return null;
+    
+    const messageDir = _join(this.storagePath!, "message", sessionId);
+
+    let messageFiles: string[];
+    try {
+      messageFiles = await _readdir(messageDir);
+    } catch {
+      return null;
+    }
+
+    let earliest: { agent: string; created: number } | null = null;
+
+    for (const fileName of messageFiles) {
+      if (!fileName.endsWith(".json")) continue;
+
+      const filePath = _join(messageDir, fileName);
+      const raw = await this.readJsonFile<OpenCodeMessageRaw>(filePath);
+      if (!raw) continue;
+
+      if (!earliest || raw.time.created < earliest.created) {
+        earliest = { agent: (raw.agent || "build").toLowerCase(), created: raw.time.created };
+      }
+    }
+
+    return earliest?.agent ?? null;
+  }
+
+  private async getMessageContent(messageId: string): Promise<string | null> {
+    const partDir = _join(this.storagePath!, "part", messageId);
+
+    let partFiles: string[];
+    try {
+      partFiles = await _readdir(partDir);
+    } catch {
+      return null;
+    }
+
+    const textParts: { text: string; time?: number }[] = [];
+
+    for (const fileName of partFiles) {
+      if (!fileName.endsWith(".json")) continue;
+
+      const filePath = _join(partDir, fileName);
+      const raw = await this.readJsonFile<OpenCodePartRaw>(filePath);
+      if (!raw) continue;
+
+      if (raw.type !== "text") continue;
+      if (raw.synthetic === true) continue;
+      if (!raw.text) continue;
+
+      textParts.push({
+        text: raw.text,
+        time: raw.time?.start,
+      });
+    }
+
+    if (textParts.length === 0) return null;
+
+    textParts.sort((a, b) => (a.time ?? 0) - (b.time ?? 0));
+    return textParts.map((p) => p.text).join("\n\n");
+  }
+
+  private async readJsonFile<T>(filePath: string): Promise<T | null> {
+    try {
+      const text = await _readFile(filePath, "utf-8");
+      if (!text) return null;
+      return JSON.parse(text) as T;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/integrations/opencode/reader-factory.ts

@@ -0,0 +1,35 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import type { IOpenCodeReader } from "./types.js";
+import { JsonReader } from "./json-reader.js";
+
+export async function createOpenCodeReader(basePath?: string): Promise<IOpenCodeReader> {
+  const dataDir = basePath ?? getDefaultDataDir();
+  const dbPath = join(dataDir, "opencode.db");
+  const storagePath = join(dataDir, "storage");
+
+  if (existsSync(dbPath)) {
+    try {
+      const { SqliteReader } = await import("./sqlite-reader.js");
+      console.log("[OpenCode] Using SQLite reader");
+      return new SqliteReader(dbPath);
+    } catch {
+      console.log("[OpenCode] SQLite not available, falling back to JSON reader");
+    }
+  }
+
+  if (existsSync(storagePath)) {
+    console.log("[OpenCode] Using JSON reader (legacy)");
+    return new JsonReader(storagePath);
+  }
+
+  console.log("[OpenCode] No OpenCode data found");
+  return new JsonReader(storagePath);
+}
+
+function getDefaultDataDir(): string {
+  return (
+    process.env.EI_OPENCODE_DATA_PATH ??
+    join(process.env.HOME || "~", ".local", "share", "opencode")
+  );
+}

package/src/integrations/opencode/sqlite-reader.ts

@@ -0,0 +1,189 @@
+import { Database } from "bun:sqlite";
+import type {
+  IOpenCodeReader,
+  OpenCodeSession,
+  OpenCodeMessage,
+  OpenCodeAgent,
+} from "./types.js";
+import { BUILTIN_AGENTS } from "./types.js";
+
+export class SqliteReader implements IOpenCodeReader {
+  private db: Database;
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath, { readonly: true });
+  }
+
+  async getSessionsUpdatedSince(since: Date): Promise<OpenCodeSession[]> {
+    const sinceMs = since.getTime();
+    const rows = this.db
+      .query(
+        `
+      SELECT id, title, directory, project_id, parent_id, time_created, time_updated
+      FROM session
+      WHERE time_updated > ?1 AND parent_id IS NULL
+      ORDER BY time_updated DESC
+    `
+      )
+      .all(sinceMs) as Array<{
+      id: string;
+      title: string;
+      directory: string;
+      project_id: string;
+      parent_id: string | null;
+      time_created: number;
+      time_updated: number;
+    }>;
+
+    return rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      directory: row.directory,
+      projectId: row.project_id,
+      parentId: row.parent_id ?? undefined,
+      time: {
+        created: row.time_created,
+        updated: row.time_updated,
+      },
+    }));
+  }
+
+  async getSessionsInRange(from: Date, to: Date): Promise<OpenCodeSession[]> {
+    const fromMs = from.getTime();
+    const toMs = to.getTime();
+    const rows = this.db
+      .query(
+        `
+      SELECT id, title, directory, project_id, parent_id, time_created, time_updated
+      FROM session
+      WHERE time_updated > ?1 AND time_updated <= ?2 AND parent_id IS NULL
+      ORDER BY time_updated ASC
+    `
+      )
+      .all(fromMs, toMs) as Array<{
+      id: string;
+      title: string;
+      directory: string;
+      project_id: string;
+      parent_id: string | null;
+      time_created: number;
+      time_updated: number;
+    }>;
+
+    return rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      directory: row.directory,
+      projectId: row.project_id,
+      parentId: row.parent_id ?? undefined,
+      time: {
+        created: row.time_created,
+        updated: row.time_updated,
+      },
+    }));
+  }
+
+  async getMessagesForSession(
+    sessionId: string,
+    since?: Date
+  ): Promise<OpenCodeMessage[]> {
+    const sinceMs = since?.getTime() ?? 0;
+
+    const messages = this.db
+      .query(
+        `
+      SELECT id, session_id, time_created, data
+      FROM message
+      WHERE session_id = ?1 AND time_created > ?2
+      ORDER BY time_created ASC
+    `
+      )
+      .all(sessionId, sinceMs) as Array<{
+      id: string;
+      session_id: string;
+      time_created: number;
+      data: string;
+    }>;
+
+    const result: OpenCodeMessage[] = [];
+
+    for (const msg of messages) {
+      const msgData = JSON.parse(msg.data) as { role: "user" | "assistant"; agent?: string };
+      const content = this.getMessageContent(msg.id);
+      if (!content) continue;
+
+      result.push({
+        id: msg.id,
+        sessionId: msg.session_id,
+        role: msgData.role,
+        agent: (msgData.agent || "build").toLowerCase(),
+        content,
+        timestamp: new Date(msg.time_created).toISOString(),
+      });
+    }
+
+    return result;
+  }
+
+  private getMessageContent(messageId: string): string | null {
+    const parts = this.db
+      .query(
+        `
+      SELECT data, time_created FROM part 
+      WHERE message_id = ?1 
+      ORDER BY time_created ASC
+    `
+      )
+      .all(messageId) as Array<{ data: string; time_created: number }>;
+
+    const textParts: string[] = [];
+
+    for (const part of parts) {
+      const partData = JSON.parse(part.data) as {
+        type: string;
+        synthetic?: boolean;
+        text?: string;
+      };
+      if (partData.type !== "text") continue;
+      if (partData.synthetic === true) continue;
+      if (!partData.text) continue;
+      textParts.push(partData.text);
+    }
+
+    return textParts.length > 0 ? textParts.join("\n\n") : null;
+  }
+
+  async getAgentInfo(agentName: string): Promise<OpenCodeAgent | null> {
+    const normalized = agentName.toLowerCase();
+    if (BUILTIN_AGENTS[normalized]) {
+      return BUILTIN_AGENTS[normalized];
+    }
+    return { name: agentName, description: "OpenCode coding agent" };
+  }
+
+  async getAllUniqueAgents(sessionId: string): Promise<string[]> {
+    const messages = await this.getMessagesForSession(sessionId);
+    return [...new Set(messages.map((m) => m.agent))];
+  }
+
+  async getFirstAgent(sessionId: string): Promise<string | null> {
+    const row = this.db
+      .query(
+        `
+      SELECT data FROM message 
+      WHERE session_id = ?1 
+      ORDER BY time_created ASC 
+      LIMIT 1
+    `
+      )
+      .get(sessionId) as { data: string } | null;
+
+    if (!row) return null;
+    const msgData = JSON.parse(row.data) as { agent?: string };
+    return (msgData.agent || "build").toLowerCase();
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}