@axhub/genie 0.1.6 → 0.1.8

package/server/projects.js

@@ -436,7 +436,11 @@ async function getProjects(progressCallback = null) {
           displayName: customName || autoDisplayName,
           fullPath: fullPath,
           isCustomName: !!customName,
-          sessions: []
+          sessions: [],
+          cursorSessions: [],
+          codexSessions: [],
+          opencodeSessions: [],
+          geminiSessions: []
         };
         
         // Try to get sessions for this project (just first 5 for performance)
@@ -467,6 +471,20 @@ async function getProjects(progressCallback = null) {
           project.codexSessions = [];
         }
 
+        try {
+          project.geminiSessions = await getGeminiSessions(actualProjectDir);
+        } catch (e) {
+          console.warn(`Could not load Gemini sessions for project ${entry.name}:`, e.message);
+          project.geminiSessions = [];
+        }
+
+        try {
+          project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
+        } catch (e) {
+          console.warn(`Could not load OpenCode sessions for project ${entry.name}:`, e.message);
+          project.opencodeSessions = [];
+        }
+
         // Add TaskMaster detection
         try {
           const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
@@ -526,7 +544,7 @@ async function getProjects(progressCallback = null) {
         }
       }
       
-              const project = {
+       const project = {
           name: projectName,
           path: actualProjectDir,
           displayName: projectConfig.displayName || await generateDisplayName(projectName, actualProjectDir),
@@ -535,7 +553,9 @@ async function getProjects(progressCallback = null) {
           isManuallyAdded: true,
           sessions: [],
           cursorSessions: [],
-          codexSessions: []
+          codexSessions: [],
+          opencodeSessions: [],
+          geminiSessions: []
         };
 
       // Try to fetch Cursor sessions for manual projects too
@@ -552,6 +572,18 @@ async function getProjects(progressCallback = null) {
         console.warn(`Could not load Codex sessions for manual project ${projectName}:`, e.message);
       }
 
+      try {
+        project.geminiSessions = await getGeminiSessions(actualProjectDir);
+      } catch (e) {
+        console.warn(`Could not load Gemini sessions for manual project ${projectName}:`, e.message);
+      }
+
+      try {
+        project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
+      } catch (e) {
+        console.warn(`Could not load OpenCode sessions for manual project ${projectName}:`, e.message);
+      }
+
       // Add TaskMaster detection for manual projects
       try {
         const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
@@ -1129,7 +1161,10 @@ async function addProjectManually(projectPath, displayName = null) {
     displayName: displayName || await generateDisplayName(projectName, absolutePath),
     isManuallyAdded: true,
     sessions: [],
-    cursorSessions: []
+    cursorSessions: [],
+    codexSessions: [],
+    opencodeSessions: [],
+    geminiSessions: []
   };
 }
 
@@ -1321,6 +1356,607 @@ async function getCodexSessions(projectPath, options = {}) {
   }
 }
 
+const OPENCODE_SESSION_DIR_CANDIDATES = [
+  path.join(os.homedir(), '.opencode', 'sessions'),
+  path.join(os.homedir(), '.config', 'opencode', 'sessions')
+];
+
+async function findOpencodeSessionFiles() {
+  const files = [];
+
+  const walk = async (dirPath) => {
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+          files.push(fullPath);
+        }
+      }
+    } catch (_) {}
+  };
+
+  for (const baseDir of OPENCODE_SESSION_DIR_CANDIDATES) {
+    try {
+      await fs.access(baseDir);
+      await walk(baseDir);
+    } catch (_) {}
+  }
+
+  return Array.from(new Set(files));
+}
+
+function normalizeOpencodePath(pathValue) {
+  if (typeof pathValue !== 'string') {
+    return '';
+  }
+  return pathValue.startsWith('\\\\?\\') ? pathValue.slice(4) : pathValue;
+}
+
+function extractOpencodeText(value) {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map((part) => {
+        if (typeof part === 'string') {
+          return part;
+        }
+        if (part && typeof part === 'object') {
+          if (typeof part.text === 'string') {
+            return part.text;
+          }
+          if (typeof part.content === 'string') {
+            return part.content;
+          }
+          if (typeof part.value === 'string') {
+            return part.value;
+          }
+        }
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+
+  if (value && typeof value === 'object') {
+    if (typeof value.text === 'string') {
+      return value.text;
+    }
+    if (typeof value.content === 'string') {
+      return value.content;
+    }
+    if (typeof value.value === 'string') {
+      return value.value;
+    }
+  }
+
+  return '';
+}
+
+function extractOpencodeRole(entry) {
+  return (
+    entry?.role ||
+    entry?.message?.role ||
+    entry?.payload?.role ||
+    entry?.payload?.message?.role ||
+    null
+  );
+}
+
+function extractOpencodeContent(entry) {
+  return (
+    entry?.content ??
+    entry?.message?.content ??
+    entry?.payload?.content ??
+    entry?.payload?.message?.content ??
+    entry?.payload?.text ??
+    ''
+  );
+}
+
+function inferOpencodeMessageType(entry, role) {
+  const explicitType = entry?.type || entry?.payload?.type;
+  const normalizedType = typeof explicitType === 'string' ? explicitType.toLowerCase() : '';
+  const normalizedRole = typeof role === 'string' ? role.toLowerCase() : '';
+
+  if (normalizedType.includes('thinking') || normalizedType === 'reasoning') {
+    return 'thinking';
+  }
+  if (normalizedType.includes('tool_call') || normalizedType === 'function_call') {
+    return 'tool_use';
+  }
+  if (normalizedType.includes('tool_result') || normalizedType === 'function_call_output') {
+    return 'tool_result';
+  }
+  if (normalizedRole === 'user') {
+    return 'user';
+  }
+  if (normalizedRole === 'assistant') {
+    return 'assistant';
+  }
+  return null;
+}
+
+async function parseOpencodeSessionFile(filePath) {
+  const session = {
+    id: null,
+    summary: 'OpenCode Session',
+    messageCount: 0,
+    lastActivity: new Date().toISOString(),
+    cwd: '',
+    filePath,
+    provider: 'opencode'
+  };
+
+  let lastUserMessage = null;
+  let latestTimestamp = null;
+
+  try {
+    const fileStream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      if (!session.id) {
+        session.id =
+          entry?.sessionId ||
+          entry?.session_id ||
+          entry?.id ||
+          entry?.payload?.sessionId ||
+          entry?.payload?.session_id ||
+          entry?.payload?.id ||
+          null;
+      }
+
+      if (!session.cwd) {
+        session.cwd =
+          entry?.cwd ||
+          entry?.payload?.cwd ||
+          entry?.metadata?.cwd ||
+          entry?.session?.cwd ||
+          '';
+      }
+
+      if (typeof entry?.summary === 'string' && entry.summary.trim()) {
+        session.summary = entry.summary.trim();
+      } else if (typeof entry?.payload?.summary === 'string' && entry.payload.summary.trim()) {
+        session.summary = entry.payload.summary.trim();
+      }
+
+      const timestampCandidate =
+        entry?.timestamp ||
+        entry?.createdAt ||
+        entry?.updatedAt ||
+        entry?.payload?.timestamp ||
+        entry?.payload?.createdAt ||
+        null;
+
+      if (timestampCandidate) {
+        latestTimestamp = timestampCandidate;
+      }
+
+      const role = extractOpencodeRole(entry);
+      const messageType = inferOpencodeMessageType(entry, role);
+      const contentText = extractOpencodeText(extractOpencodeContent(entry));
+
+      if (messageType === 'user' || messageType === 'assistant') {
+        session.messageCount += 1;
+      }
+
+      if (messageType === 'user' && contentText.trim()) {
+        lastUserMessage = contentText;
+      }
+    }
+
+    if (!session.id) {
+      session.id = path.basename(filePath, '.jsonl');
+    }
+
+    if (session.summary === 'OpenCode Session' && lastUserMessage) {
+      session.summary = lastUserMessage.length > 50
+        ? `${lastUserMessage.substring(0, 50)}...`
+        : lastUserMessage;
+    }
+
+    if (latestTimestamp) {
+      session.lastActivity = new Date(latestTimestamp).toISOString();
+    }
+
+    return session;
+  } catch (error) {
+    console.warn(`Could not parse OpenCode session file ${filePath}:`, error.message);
+    return null;
+  }
+}
+
+async function getOpencodeSessions(projectPath, options = {}) {
+  const { limit = 5 } = options;
+
+  try {
+    const sessionFiles = await findOpencodeSessionFiles();
+    if (sessionFiles.length === 0) {
+      return [];
+    }
+
+    const sessions = [];
+    const cleanProjectPath = normalizeOpencodePath(projectPath);
+
+    for (const filePath of sessionFiles) {
+      const sessionData = await parseOpencodeSessionFile(filePath);
+      if (!sessionData) {
+        continue;
+      }
+
+      const sessionCwd = normalizeOpencodePath(sessionData.cwd);
+      if (!sessionCwd) {
+        continue;
+      }
+
+      if (
+        sessionCwd === cleanProjectPath ||
+        path.relative(sessionCwd, cleanProjectPath) === ''
+      ) {
+        sessions.push(sessionData);
+      }
+    }
+
+    sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+    return limit > 0 ? sessions.slice(0, limit) : sessions;
+  } catch (error) {
+    console.error('Error fetching OpenCode sessions:', error);
+    return [];
+  }
+}
+
+async function findOpencodeSessionFileById(sessionId) {
+  const sessionFiles = await findOpencodeSessionFiles();
+  for (const filePath of sessionFiles) {
+    if (path.basename(filePath, '.jsonl') === sessionId) {
+      return filePath;
+    }
+
+    const sessionData = await parseOpencodeSessionFile(filePath);
+    if (sessionData?.id === sessionId) {
+      return filePath;
+    }
+  }
+
+  return null;
+}
+
+async function getOpencodeSessionMessages(sessionId, limit = null, offset = 0) {
+  try {
+    const sessionFilePath = await findOpencodeSessionFileById(sessionId);
+    if (!sessionFilePath) {
+      return { messages: [], total: 0, hasMore: false };
+    }
+
+    const messages = [];
+    const fileStream = fsSync.createReadStream(sessionFilePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      const role = extractOpencodeRole(entry);
+      const messageType = inferOpencodeMessageType(entry, role);
+      const timestamp =
+        entry?.timestamp ||
+        entry?.createdAt ||
+        entry?.updatedAt ||
+        entry?.payload?.timestamp ||
+        null;
+
+      if (messageType === 'tool_use') {
+        messages.push({
+          type: 'tool_use',
+          timestamp,
+          toolName: entry?.name || entry?.payload?.name || 'tool',
+          toolInput: entry?.arguments || entry?.payload?.arguments || entry?.input || entry?.payload?.input || '',
+          toolCallId: entry?.call_id || entry?.payload?.call_id || null
+        });
+        continue;
+      }
+
+      if (messageType === 'tool_result') {
+        messages.push({
+          type: 'tool_result',
+          timestamp,
+          toolCallId: entry?.call_id || entry?.payload?.call_id || null,
+          output: entry?.output || entry?.payload?.output || ''
+        });
+        continue;
+      }
+
+      if (messageType === 'thinking') {
+        const thinkingText = extractOpencodeText(
+          entry?.summary || entry?.payload?.summary || entry?.content || entry?.payload?.content
+        );
+        if (thinkingText.trim()) {
+          messages.push({
+            type: 'thinking',
+            timestamp,
+            message: {
+              role: 'assistant',
+              content: thinkingText
+            }
+          });
+        }
+        continue;
+      }
+
+      if (messageType !== 'user' && messageType !== 'assistant') {
+        continue;
+      }
+
+      const contentText = extractOpencodeText(extractOpencodeContent(entry));
+      if (!contentText.trim()) {
+        continue;
+      }
+
+      messages.push({
+        type: messageType,
+        timestamp,
+        message: {
+          role: messageType === 'user' ? 'user' : 'assistant',
+          content: contentText
+        }
+      });
+    }
+
+    messages.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+
+    const total = messages.length;
+    if (limit !== null) {
+      const startIndex = Math.max(0, total - offset - limit);
+      const endIndex = total - offset;
+      const paginatedMessages = messages.slice(startIndex, endIndex);
+      return {
+        messages: paginatedMessages,
+        total,
+        hasMore: startIndex > 0,
+        offset,
+        limit
+      };
+    }
+
+    return { messages, total, hasMore: false };
+  } catch (error) {
+    console.error(`Error reading OpenCode session messages for ${sessionId}:`, error);
+    return { messages: [], total: 0, hasMore: false };
+  }
+}
+
+async function deleteOpencodeSession(sessionId) {
+  try {
+    const sessionFilePath = await findOpencodeSessionFileById(sessionId);
+    if (!sessionFilePath) {
+      throw new Error(`OpenCode session file not found for session ${sessionId}`);
+    }
+
+    await fs.unlink(sessionFilePath);
+    return true;
+  } catch (error) {
+    console.error(`Error deleting OpenCode session ${sessionId}:`, error);
+    throw error;
+  }
+}
+
+async function getGeminiSessions(projectPath, options = {}) {
+  const { limit = 5 } = options;
+  try {
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    try {
+      await fs.access(geminiTmpDir);
+    } catch {
+      return [];
+    }
+
+    const projectHash = crypto.createHash('sha256').update(projectPath).digest('hex');
+    const chatsDir = path.join(geminiTmpDir, projectHash, 'chats');
+
+    try {
+      await fs.access(chatsDir);
+    } catch {
+      return [];
+    }
+
+    const entries = await fs.readdir(chatsDir, { withFileTypes: true });
+    const sessionFiles = entries
+      .filter(e => e.isFile() && e.name.endsWith('.json'))
+      .map(e => path.join(chatsDir, e.name));
+
+    const sessions = [];
+    for (const filePath of sessionFiles) {
+      try {
+        const sessionData = await parseGeminiSessionFile(filePath);
+        if (!sessionData?.id) continue;
+        sessions.push(sessionData);
+      } catch (error) {
+        console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
+      }
+    }
+
+    sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+    return limit > 0 ? sessions.slice(0, limit) : sessions;
+  } catch (error) {
+    console.error('Error fetching Gemini sessions:', error);
+    return [];
+  }
+}
+
+async function parseGeminiSessionFile(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  const data = JSON.parse(raw);
+  const messages = Array.isArray(data?.messages) ? data.messages : [];
+
+  let summary = 'Gemini Session';
+  let messageCount = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg?.type === 'user') {
+      const userText = Array.isArray(msg?.content)
+        ? msg.content.map(p => p?.text).filter(Boolean).join('\n')
+        : typeof msg?.content === 'string'
+          ? msg.content
+          : '';
+      if (userText.trim()) {
+        summary = userText.length > 50 ? `${userText.substring(0, 50)}...` : userText;
+        break;
+      }
+    }
+  }
+
+  messageCount = messages.filter(m => m?.type === 'user' || m?.type === 'gemini').length;
+
+  const lastActivity = data?.lastUpdated || data?.startTime || new Date().toISOString();
+  return {
+    id: data?.sessionId,
+    summary,
+    messageCount,
+    lastActivity,
+    createdAt: data?.startTime || lastActivity,
+    model: messages.filter(m => m?.model).slice(-1)[0]?.model || null,
+    provider: 'gemini',
+    filePath
+  };
+}
+
+async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
+  try {
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    const findSessionFile = async (dir) => {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            const found = await findSessionFile(fullPath);
+            if (found) return found;
+            continue;
+          }
+          if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+          try {
+            const raw = await fs.readFile(fullPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed?.sessionId === sessionId) {
+              return fullPath;
+            }
+          } catch {}
+        }
+      } catch {}
+      return null;
+    };
+
+    const sessionFilePath = await findSessionFile(geminiTmpDir);
+    if (!sessionFilePath) {
+      return { messages: [], total: 0, hasMore: false };
+    }
+
+    const raw = await fs.readFile(sessionFilePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const sourceMessages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+    const messages = [];
+
+    for (const msg of sourceMessages) {
+      if (msg?.type === 'user') {
+        const content = Array.isArray(msg?.content)
+          ? msg.content.map(p => p?.text).filter(Boolean).join('\n')
+          : typeof msg?.content === 'string'
+            ? msg.content
+            : '';
+        if (content.trim()) {
+          messages.push({
+            type: 'user',
+            timestamp: msg.timestamp,
+            message: {
+              role: 'user',
+              content
+            }
+          });
+        }
+      } else if (msg?.type === 'gemini' && typeof msg?.content === 'string' && msg.content.trim()) {
+        messages.push({
+          type: 'assistant',
+          timestamp: msg.timestamp,
+          message: {
+            role: 'assistant',
+            content: msg.content
+          }
+        });
+
+        if (Array.isArray(msg.thoughts) && msg.thoughts.length > 0) {
+          const thoughtText = msg.thoughts
+            .map(t => [t?.subject, t?.description].filter(Boolean).join(': '))
+            .filter(Boolean)
+            .join('\n');
+          if (thoughtText) {
+            messages.push({
+              type: 'thinking',
+              timestamp: msg.timestamp,
+              message: {
+                role: 'assistant',
+                content: thoughtText
+              }
+            });
+          }
+        }
+      }
+    }
+
+    messages.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+
+    const total = messages.length;
+    if (limit !== null) {
+      const startIndex = Math.max(0, total - offset - limit);
+      const endIndex = total - offset;
+      const paginatedMessages = messages.slice(startIndex, endIndex);
+      return {
+        messages: paginatedMessages,
+        total,
+        hasMore: startIndex > 0,
+        offset,
+        limit
+      };
+    }
+
+    return { messages, total, hasMore: false };
+  } catch (error) {
+    console.error(`Error reading Gemini session messages for ${sessionId}:`, error);
+    return { messages: [], total: 0, hasMore: false };
+  }
+}
+
 // Parse a Codex session JSONL file to extract metadata
 async function parseCodexSessionFile(filePath) {
   try {
@@ -1675,5 +2311,9 @@ export {
   clearProjectDirectoryCache,
   getCodexSessions,
   getCodexSessionMessages,
-  deleteCodexSession
+  getOpencodeSessions,
+  getOpencodeSessionMessages,
+  getGeminiSessionMessages,
+  deleteCodexSession,
+  deleteOpencodeSession
 };