@loreai/core 0.17.1 → 0.19.0

package/src/import/providers/continue.ts

@@ -0,0 +1,304 @@
+/**
+ * Continue (VS Code/JetBrains extension) conversation history provider.
+ *
+ * Reads JSON session files from ~/.continue/sessions/<sessionId>.json
+ * with the sessions index at ~/.continue/sessions/sessions.json.
+ *
+ * Each session JSON contains:
+ *   { sessionId, title, workspaceDirectory, history: ChatHistoryItem[] }
+ *
+ * The CONTINUE_GLOBAL_DIR env var overrides the default ~/.continue path.
+ */
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { AgentHistoryProvider, ConversationChunk, DetectedSession } from "../types";
+import { registerProvider } from "./index";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_TOOL_OUTPUT_CHARS = 500;
+const DEFAULT_MAX_TOKENS = 12288;
+
+// ---------------------------------------------------------------------------
+// Types (Continue's format)
+// ---------------------------------------------------------------------------
+
+type SessionMetadata = {
+  sessionId: string;
+  title: string;
+  dateCreated: string;
+  workspaceDirectory?: string;
+  messageCount?: number;
+};
+
+type ChatMessage = {
+  role: "user" | "assistant" | "system" | "tool";
+  content: string | ContentPart[];
+  toolCalls?: ToolCall[];
+};
+
+type ContentPart =
+  | { type: "text"; text: string }
+  | { type: "imageUrl"; imageUrl?: { url: string } }
+  | { type: string; [key: string]: unknown };
+
+type ToolCall = {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+};
+
+type ChatHistoryItem = {
+  message: ChatMessage;
+  contextItems?: unknown[];
+  toolCallStates?: Array<{
+    toolCallId: string;
+    status: string;
+    output?: string;
+  }>;
+};
+
+type SessionFile = {
+  sessionId: string;
+  title: string;
+  workspaceDirectory?: string;
+  history: ChatHistoryItem[];
+  mode?: string;
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 3);
+}
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + "...";
+}
+
+/** Get the Continue global directory. */
+function continueDir(): string {
+  return process.env.CONTINUE_GLOBAL_DIR || join(homedir(), ".continue");
+}
+
+/** Load the sessions index. */
+function loadSessionIndex(): SessionMetadata[] {
+  const indexPath = join(continueDir(), "sessions", "sessions.json");
+  if (!existsSync(indexPath)) return [];
+
+  try {
+    const raw = readFileSync(indexPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Load a full session file. */
+function loadSession(sessionId: string): SessionFile | null {
+  const filePath = join(continueDir(), "sessions", `${sessionId}.json`);
+  if (!existsSync(filePath)) return null;
+
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw) as SessionFile;
+  } catch {
+    return null;
+  }
+}
+
+/** Extract text from a chat message's content. */
+function extractMessageContent(content: string | ContentPart[]): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  return content
+    .filter((part): part is { type: "text"; text: string } =>
+      part.type === "text" && typeof (part as { text?: string }).text === "string",
+    )
+    .map((part) => part.text)
+    .join("\n");
+}
+
+/** Convert a ChatHistoryItem to text. */
+function historyItemToText(item: ChatHistoryItem): string | null {
+  const msg = item.message;
+  if (!msg) return null;
+
+  // Skip system messages
+  if (msg.role === "system") return null;
+
+  const parts: string[] = [];
+
+  // Message content
+  const content = extractMessageContent(msg.content);
+  if (content) parts.push(content);
+
+  // Tool calls (from assistant)
+  if (msg.toolCalls) {
+    for (const call of msg.toolCalls) {
+      if (call.function) {
+        const args = truncate(call.function.arguments || "{}", MAX_TOOL_OUTPUT_CHARS);
+        parts.push(`[tool: ${call.function.name}] ${args}`);
+      }
+    }
+  }
+
+  // Tool call results
+  if (item.toolCallStates) {
+    for (const state of item.toolCallStates) {
+      if (state.output && state.status === "done") {
+        parts.push(`[tool_result] ${truncate(state.output, MAX_TOOL_OUTPUT_CHARS)}`);
+      }
+    }
+  }
+
+  if (parts.length === 0) return null;
+
+  const role = msg.role === "tool" ? "tool_result" : msg.role;
+  return `[${role}] ${parts.join("\n")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Provider implementation
+// ---------------------------------------------------------------------------
+
+const continueProvider: AgentHistoryProvider = {
+  name: "continue",
+  displayName: "Continue",
+
+  detect(projectPath: string): DetectedSession[] {
+    const sessions: DetectedSession[] = [];
+    const index = loadSessionIndex();
+
+    for (const meta of index) {
+      // Filter by workspace directory
+      if (meta.workspaceDirectory !== projectPath) continue;
+
+      // Load the full session to count messages
+      const session = loadSession(meta.sessionId);
+      if (!session || !session.history || session.history.length < 3) continue;
+
+      const ts = new Date(meta.dateCreated).getTime();
+      const dateStr = new Date(ts).toISOString().slice(0, 10);
+      const messageCount = session.history.length;
+
+      const label = meta.title
+        ? `${dateStr} - ${truncate(meta.title, 60)} (${messageCount} messages)`
+        : `${dateStr} (${messageCount} messages)`;
+
+      // Estimate tokens
+      const estimatedTokens = messageCount * 500;
+
+      sessions.push({
+        id: meta.sessionId,
+        label,
+        startedAt: ts,
+        lastActivityAt: ts,
+        estimatedTokens,
+        messageCount,
+      });
+    }
+
+    // Also scan for session files not in the index (some versions don't maintain it)
+    const sessionsDir = join(continueDir(), "sessions");
+    if (existsSync(sessionsDir)) {
+      const existingIds = new Set(sessions.map((s) => s.id));
+      let entries: string[];
+      try {
+        entries = readdirSync(sessionsDir);
+      } catch {
+        entries = [];
+      }
+
+      for (const entry of entries) {
+        if (!entry.endsWith(".json") || entry === "sessions.json") continue;
+        const sessionId = entry.replace(".json", "");
+        if (existingIds.has(sessionId)) continue;
+
+        const session = loadSession(sessionId);
+        if (!session) continue;
+        if (session.workspaceDirectory !== projectPath) continue;
+        if (!session.history || session.history.length < 3) continue;
+
+        const dateStr = session.title ? truncate(session.title, 60) : sessionId.slice(0, 8);
+        sessions.push({
+          id: sessionId,
+          label: `${dateStr} (${session.history.length} messages)`,
+          startedAt: Date.now(),
+          lastActivityAt: Date.now(),
+          estimatedTokens: session.history.length * 500,
+          messageCount: session.history.length,
+        });
+      }
+    }
+
+    return sessions.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+  },
+
+  readChunks(
+    _projectPath: string,
+    sessionIds: string[],
+    maxTokens: number = DEFAULT_MAX_TOKENS,
+  ): ConversationChunk[] {
+    const chunks: ConversationChunk[] = [];
+
+    for (const sessionId of sessionIds) {
+      const session = loadSession(sessionId);
+      if (!session || !session.history) continue;
+
+      const textMessages: { text: string }[] = [];
+      for (const item of session.history) {
+        const text = historyItemToText(item);
+        if (text) textMessages.push({ text });
+      }
+
+      if (textMessages.length === 0) continue;
+
+      // Session timestamp
+      const sessionTimestamp = Date.now();
+
+      // Build chunks respecting maxTokens boundaries
+      let currentTexts: string[] = [];
+      let currentTokens = 0;
+      let chunkIndex = 0;
+
+      const flushChunk = () => {
+        if (currentTexts.length === 0) return;
+        chunkIndex++;
+        const text = currentTexts.join("\n\n");
+        chunks.push({
+          label: `Continue ${session.title || sessionId.slice(0, 8)} (${chunkIndex})`,
+          text,
+          estimatedTokens: estimateTokens(text),
+          timestamp: sessionTimestamp,
+        });
+        currentTexts = [];
+        currentTokens = 0;
+      };
+
+      for (const msg of textMessages) {
+        const msgTokens = estimateTokens(msg.text);
+        if (currentTokens > 0 && currentTokens + msgTokens > maxTokens) {
+          flushChunk();
+        }
+        currentTexts.push(msg.text);
+        currentTokens += msgTokens;
+      }
+
+      flushChunk();
+    }
+
+    return chunks;
+  },
+};
+
+// Auto-register on import
+registerProvider(continueProvider);

package/src/import/providers/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider registry — maintains a list of all known agent history providers.
+ *
+ * Providers register themselves at import time. The detection orchestrator
+ * iterates over all registered providers to scan for conversation history.
+ */
+import type { AgentHistoryProvider } from "../types";
+
+const providers: AgentHistoryProvider[] = [];
+
+/** Register a provider. Called at module load time by each provider module. */
+export function registerProvider(provider: AgentHistoryProvider): void {
+  providers.push(provider);
+}
+
+/** Get all registered providers. */
+export function getProviders(): readonly AgentHistoryProvider[] {
+  return providers;
+}
+
+/** Get a provider by internal name. */
+export function getProvider(name: string): AgentHistoryProvider | undefined {
+  return providers.find((p) => p.name === name);
+}
+
+/**
+ * Clear all registered providers.
+ * Test-only — allows resetting the registry between test runs.
+ */
+export function clearProviders(): void {
+  providers.length = 0;
+}

package/src/import/providers/opencode.ts

@@ -0,0 +1,272 @@
+/**
+ * OpenCode conversation history provider.
+ *
+ * Reads from OpenCode's SQLite database at ~/.local/share/opencode/opencode.db.
+ * The message.data and part.data JSON fields use a format very close to lore's
+ * own LoreMessage/LorePart types (since lore was designed for OpenCode).
+ */
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { Database } from "#db/driver";
+import type { AgentHistoryProvider, ConversationChunk, DetectedSession } from "../types";
+import { registerProvider } from "./index";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const OPENCODE_DB_PATH = join(
+  process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"),
+  "opencode",
+  "opencode.db",
+);
+const MAX_TOOL_OUTPUT_CHARS = 500;
+const DEFAULT_MAX_TOKENS = 12288;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 3);
+}
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + "...";
+}
+
+/**
+ * Open OpenCode's database read-only.
+ * Returns null if the DB doesn't exist or can't be opened.
+ *
+ * Bun's `Database` uses `{ readonly: true }` while Node.js's `DatabaseSync`
+ * uses `{ readOnly: true }`. We pass both via a cast to cover both runtimes.
+ */
+function openDB(): InstanceType<typeof Database> | null {
+  if (!existsSync(OPENCODE_DB_PATH)) return null;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new Database(OPENCODE_DB_PATH, { readonly: true, readOnly: true } as any);
+  } catch {
+    return null;
+  }
+}
+
+/** Check if a table exists in the database. */
+function tableExists(database: InstanceType<typeof Database>, table: string): boolean {
+  const row = database
+    .query("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+    .get(table) as { name: string } | null;
+  return row != null;
+}
+
+type PartData = {
+  type: string;
+  text?: string;
+  tool?: string;
+  state?: {
+    status: string;
+    output?: string;
+  };
+};
+
+/** Convert part data rows into conversation text. */
+function partsToConversationText(parts: PartData[]): string {
+  const segments: string[] = [];
+  for (const part of parts) {
+    if (part.type === "text" && part.text) {
+      segments.push(part.text);
+    } else if (part.type === "tool" && part.tool && part.state?.status === "completed" && part.state.output) {
+      segments.push(`[tool: ${part.tool}] ${truncate(part.state.output, MAX_TOOL_OUTPUT_CHARS)}`);
+    }
+    // Skip reasoning, step-start, and other non-text parts
+  }
+  return segments.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Provider implementation
+// ---------------------------------------------------------------------------
+
+const opencodeProvider: AgentHistoryProvider = {
+  name: "opencode",
+  displayName: "OpenCode",
+
+  detect(projectPath: string): DetectedSession[] {
+    const database = openDB();
+    if (!database) return [];
+
+    try {
+      // Check required tables exist
+      if (!tableExists(database, "project") || !tableExists(database, "session") || !tableExists(database, "message")) {
+        return [];
+      }
+
+      // Find the project by worktree path
+      const project = database
+        .query("SELECT id FROM project WHERE worktree = ?")
+        .get(projectPath) as { id: string } | null;
+      if (!project) return [];
+
+      // Get sessions with message counts
+      const sessions = database
+        .query(
+          `SELECT s.id, s.title, s.time_created, s.time_updated,
+                  (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) as msg_count
+           FROM session s
+           WHERE s.project_id = ? AND s.parent_id IS NULL
+           ORDER BY s.time_updated DESC`,
+        )
+        .all(project.id) as Array<{
+        id: string;
+        title: string;
+        time_created: number;
+        time_updated: number;
+        msg_count: number;
+      }>;
+
+      const results: DetectedSession[] = [];
+      for (const sess of sessions) {
+        // Skip trivially small sessions
+        if (sess.msg_count < 3) continue;
+
+        // Estimate tokens from message count (rough: ~500 tokens/message avg)
+        const estimatedTokens = sess.msg_count * 500;
+        const dateStr = new Date(sess.time_created).toISOString().slice(0, 10);
+        const label = sess.title
+          ? `${dateStr} - ${sess.title} (${sess.msg_count} messages)`
+          : `${dateStr} (${sess.msg_count} messages)`;
+
+        results.push({
+          id: sess.id,
+          label,
+          startedAt: sess.time_created,
+          lastActivityAt: sess.time_updated,
+          estimatedTokens,
+          messageCount: sess.msg_count,
+        });
+      }
+
+      return results;
+    } finally {
+      database.close();
+    }
+  },
+
+  readChunks(
+    _projectPath: string,
+    sessionIds: string[],
+    maxTokens: number = DEFAULT_MAX_TOKENS,
+  ): ConversationChunk[] {
+    const database = openDB();
+    if (!database) return [];
+
+    const chunks: ConversationChunk[] = [];
+
+    try {
+      const hasParts = tableExists(database, "part");
+
+      for (const sessionId of sessionIds) {
+        // Get messages ordered by time
+        const messages = database
+          .query(
+            `SELECT id, data, time_created FROM message
+             WHERE session_id = ?
+             ORDER BY time_created ASC`,
+          )
+          .all(sessionId) as Array<{
+          id: string;
+          data: string;
+          time_created: number;
+        }>;
+
+        if (messages.length === 0) continue;
+
+        const textMessages: { text: string; timestamp: number }[] = [];
+
+        for (const msg of messages) {
+          let msgData: { role?: string };
+          try {
+            msgData = JSON.parse(msg.data);
+          } catch {
+            continue;
+          }
+
+          const role = msgData.role ?? "unknown";
+          let contentText = "";
+
+          if (hasParts) {
+            // Read parts for this message
+            const parts = database
+              .query(
+                `SELECT data FROM part
+                 WHERE message_id = ?
+                 ORDER BY time_created ASC`,
+              )
+              .all(msg.id) as Array<{ data: string }>;
+
+            const parsedParts: PartData[] = [];
+            for (const p of parts) {
+              try {
+                parsedParts.push(JSON.parse(p.data) as PartData);
+              } catch {
+                // Skip malformed parts
+              }
+            }
+            contentText = partsToConversationText(parsedParts);
+          }
+
+          if (!contentText.trim()) continue;
+
+          textMessages.push({
+            text: `[${role}] ${contentText}`,
+            timestamp: msg.time_created,
+          });
+        }
+
+        if (textMessages.length === 0) continue;
+
+        // Build chunks respecting maxTokens boundaries
+        let currentTexts: string[] = [];
+        let currentTokens = 0;
+        let chunkStart = textMessages[0].timestamp;
+        let chunkIndex = 0;
+
+        const flushChunk = () => {
+          if (currentTexts.length === 0) return;
+          chunkIndex++;
+          const text = currentTexts.join("\n\n");
+          chunks.push({
+            label: `OpenCode ${new Date(chunkStart).toISOString().slice(0, 10)} (${chunkIndex})`,
+            text,
+            estimatedTokens: estimateTokens(text),
+            timestamp: chunkStart,
+          });
+          currentTexts = [];
+          currentTokens = 0;
+        };
+
+        for (const msg of textMessages) {
+          const msgTokens = estimateTokens(msg.text);
+          if (currentTokens > 0 && currentTokens + msgTokens > maxTokens) {
+            flushChunk();
+            chunkStart = msg.timestamp;
+          }
+          currentTexts.push(msg.text);
+          currentTokens += msgTokens;
+        }
+
+        flushChunk();
+      }
+    } finally {
+      database.close();
+    }
+
+    return chunks;
+  },
+};
+
+// Auto-register on import
+registerProvider(opencodeProvider);