coding-tool-x 3.8.0 → 3.8.2

package/src/server/services/session-history-adapters/gemini.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { HOME_DIR } = require('../../../config/paths');
+const { getGeminiDir } = require('../gemini-config');
+
+const HASH_RE = /^[a-f0-9]{64}$/;
+const SESSION_FILE_RE = /^session-(.*)-([a-f0-9]+)\.(json|jsonl)$/;
+
+/**
+ * Extract text content from Gemini message parts.
+ */
+function extractContentText(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    return value
+      .map(item => {
+        if (typeof item === 'string') return item;
+        if (item && item.text) return item.text;
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+/**
+ * Load storage-name → project root mapping from projects.json.
+ */
+function loadProjectRootsByStorageName() {
+  const projectsPath = path.join(getGeminiDir(), 'projects.json');
+  try {
+    const content = fs.readFileSync(projectsPath, 'utf8');
+    const parsed = JSON.parse(content);
+    const projects = parsed && typeof parsed.projects === 'object' ? parsed.projects : {};
+    return new Map(
+      Object.entries(projects)
+        .filter(([, storageName]) => typeof storageName === 'string')
+        .map(([projectRoot, storageName]) => [storageName, projectRoot])
+    );
+  } catch {
+    return new Map();
+  }
+}
+
+/**
+ * Compute project hash from path.
+ */
+function getFilePathHash(filePath) {
+  return crypto.createHash('sha256').update(filePath).digest('hex');
+}
+
+/**
+ * Normalize a Gemini message record.
+ */
+function normalizeMessageRecord(record, provider = null, model = null) {
+  const isUser =
+    record.type === 'user' ||
+    record.role === 'user' ||
+    record.author === 'user' ||
+    record.author === 'human';
+
+  const isAssistant =
+    record.type === 'assistant' ||
+    record.type === 'gemini' ||
+    record.role === 'assistant' ||
+    record.type === 'ai' ||
+    record.author === 'ai' ||
+    record.author === 'assistant';
+
+  let role = 'unknown';
+  if (isUser) role = 'user';
+  else if (isAssistant) role = 'assistant';
+  else if (record.type === 'system' || record.role === 'system') role = 'system';
+  else role = record.type || record.role || 'unknown';
+
+  const content = extractContentText(record.content || record.message || record.parts || '');
+  const subtype = record.subtype || null;
+
+  return {
+    messageId: record.id || record.messageId || null,
+    role,
+    type: record.type || role,
+    subtype,
+    content: content || '',
+    timestamp: record.timestamp || null,
+    model: record.model || model || null,
+    provider: record.provider || provider || null,
+    userMessageNumber: null, // filled later
+    usage: record.tokens || record.usage || null,
+    extraJson: null
+  };
+}
+
+/**
+ * Parse a Gemini session file (supports both JSON and JSONL formats).
+ * @param {string} filePath
+ * @param {string} sessionId
+ * @returns {{ messages: Array, meta: object }}
+ */
+function parseSessionContent(filePath, sessionId) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  if (!raw.trim()) return { messages: [], meta: { sessionId, messages: [] } };
+
+  // Try JSON first
+  try {
+    const parsed = JSON.parse(raw);
+    // Handle $set-style JSONL updates: extract only the latest state
+    if (parsed.$set) return parseSessionContentFromState(parsed.$set, sessionId);
+    if (parsed.messages) return parseSessionContentFromState(parsed, sessionId);
+    return { messages: [], meta: { sessionId, messages: [] } };
+  } catch (_) {
+    // JSONL format: line-by-line $set/message updates
+    return parseJsonlContent(raw, sessionId);
+  }
+}
+
+function parseSessionContentFromState(state, sessionId) {
+  const meta = {
+    sessionId: state.sessionId || state.id || sessionId,
+    projectHash: state.projectHash || state.project_hash || null,
+    projectPath: state.projectPath || state.project_path || null,
+    lastUpdated: state.lastUpdated || state.last_updated || null,
+    messages: state.messages || []
+  };
+  const messages = (state.messages || []).map(m => normalizeMessageRecord(m));
+
+  let userNum = 0;
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      userNum++;
+      msg.userMessageNumber = userNum;
+    }
+  }
+
+  return { messages, meta };
+}
+
+function parseJsonlContent(raw, sessionId) {
+  const lines = raw.split('\n').filter(l => l.trim());
+  const messagesById = new Map();
+  const meta = { sessionId, projectHash: null, projectPath: null, lastUpdated: null, messages: [] };
+
+  for (const line of lines) {
+    try {
+      const record = JSON.parse(line);
+      if (record.$set) {
+        Object.assign(meta, {
+          sessionId: record.$set.sessionId || record.$set.id || meta.sessionId,
+          projectHash: record.$set.projectHash || record.$set.project_hash || meta.projectHash,
+          projectPath: record.$set.projectPath || record.$set.project_path || meta.projectPath,
+          lastUpdated: record.$set.lastUpdated || record.$set.last_updated || meta.lastUpdated
+        });
+        if (record.$set.messages) meta.messages = record.$set.messages;
+      } else if (record.type === 'session') {
+        meta.sessionId = record.id || record.sessionId || meta.sessionId;
+        meta.projectHash = record.projectHash || record.project_hash || meta.projectHash;
+        meta.projectPath = record.projectPath || record.project_path || record.cwd || meta.projectPath;
+        meta.lastUpdated = record.lastUpdated || record.last_updated || meta.lastUpdated;
+      } else if ((record.sessionId || record.id) && !record.type) {
+        meta.sessionId = record.sessionId || record.id || meta.sessionId;
+        meta.projectHash = record.projectHash || record.project_hash || meta.projectHash;
+        meta.projectPath = record.projectPath || record.project_path || record.cwd || meta.projectPath;
+        meta.lastUpdated = record.lastUpdated || record.last_updated || meta.lastUpdated;
+      } else if (record.type) {
+        const normalized = normalizeMessageRecord(record);
+        messagesById.set(normalized.messageId || `line-${messagesById.size}`, normalized);
+      }
+    } catch (_) {}
+  }
+
+  if (messagesById.size === 0 && meta.messages.length > 0) {
+    meta.messages.forEach((message, index) => messagesById.set(message.id || `state-${index}`, normalizeMessageRecord(message)));
+  }
+  const messages = Array.from(messagesById.values());
+  let userNum = 0;
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      userNum++;
+      msg.userMessageNumber = userNum;
+    }
+  }
+  return { messages, meta };
+}
+
+/**
+ * Inventory all Gemini session files.
+ * @returns {Promise<Array>}
+ */
+async function inventory() {
+  const descriptors = [];
+  const tmpDir = path.join(getGeminiDir(), 'tmp');
+
+  if (!fs.existsSync(tmpDir)) return descriptors;
+
+  const projectRoots = loadProjectRootsByStorageName();
+  let entries;
+  try {
+    entries = fs.readdirSync(tmpDir, { withFileTypes: true });
+  } catch (_) {
+    return descriptors;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const hashDir = path.join(tmpDir, entry.name);
+    const chatsDir = path.join(hashDir, 'chats');
+    if (!fs.existsSync(chatsDir)) continue;
+
+    let chatFiles;
+    try {
+      chatFiles = fs.readdirSync(chatsDir);
+    } catch (_) {
+      continue;
+    }
+
+    for (const f of chatFiles) {
+      const match = f.match(SESSION_FILE_RE);
+      if (!match) continue;
+      const filePath = path.join(chatsDir, f);
+      let stat;
+      try {
+        stat = fs.statSync(filePath);
+      } catch (_) {
+        continue;
+      }
+      const projectRoot = projectRoots.get(entry.name) || (() => {
+        try {
+          return fs.readFileSync(path.join(hashDir, '.project_root'), 'utf8').trim() || null;
+        } catch (_) {
+          return null;
+        }
+      })();
+
+      descriptors.push({
+        filePath,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        sessionId: match[1],
+        projectName: projectRoot ? getFilePathHash(projectRoot) : entry.name,
+        projectRoot
+      });
+    }
+  }
+
+  return descriptors;
+}
+
+/**
+ * Parse a Gemini session file.
+ */
+async function parse(descriptor) {
+  const { filePath, size, mtimeMs, sessionId, projectName, projectRoot } = descriptor;
+
+  const { messages, meta } = parseSessionContent(filePath, sessionId);
+  const resolvedSessionId = meta.sessionId || sessionId;
+  const resolvedProjectName = meta.projectHash || projectName || 'unknown';
+  const resolvedProjectPath = meta.projectPath || projectRoot || null;
+  const firstUserMsg = messages.find(m => m.role === 'user' && m.content);
+  const usage = messages.reduce((total, message) => {
+    const value = message.usage || {};
+    total.input += Number(value.input || value.inputTokens || 0);
+    total.output += Number(value.output || value.outputTokens || 0);
+    total.cached += Number(value.cached || value.cachedTokens || 0);
+    total.reasoning += Number(value.reasoning || value.reasoningTokens || 0);
+    total.total += Number(value.total || value.totalTokens || 0);
+    return total;
+  }, { input: 0, output: 0, cached: 0, reasoning: 0, total: 0 });
+  const lastMsg = messages[messages.length - 1];
+
+  const session = {
+    sessionId: resolvedSessionId,
+    projectName: resolvedProjectName,
+    projectDisplayName: resolvedProjectPath ? path.basename(resolvedProjectPath) : `Project ${resolvedProjectName.substring(0, 8)}`,
+    projectFullPath: resolvedProjectPath,
+    firstMessage: firstUserMsg ? firstUserMsg.content : null,
+    gitBranch: null,
+    provider: null,
+    model: messages.find(m => m.model)?.model || null,
+    startedAt: messages[0] ? messages[0].timestamp : null,
+    updatedAt: meta.lastUpdated || (lastMsg ? (lastMsg.timestamp || mtimeMs) : mtimeMs),
+    usageJson: JSON.stringify(usage),
+    extraJson: JSON.stringify({ projectPath: resolvedProjectPath, storageName: path.basename(path.dirname(path.dirname(filePath))) })
+  };
+
+  return { session, messages };
+}
+
+module.exports = { inventory, parse, extractContentText, normalizeMessageRecord, parseSessionContent };

package/src/server/services/session-history-adapters/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function optionalAdapter(name) {
+  try {
+    return require(`./${name}`);
+  } catch (_) {
+    return {
+      inventory: async () => [],
+      parse: async () => ({ session: null, messages: [] })
+    };
+  }
+}
+
+module.exports = {
+  claude: optionalAdapter('claude'),
+  codex: optionalAdapter('codex'),
+  gemini: optionalAdapter('gemini'),
+  omp: optionalAdapter('omp')
+  // OpenCode uses its own native schema; not indexed via adapters
+};

package/src/server/services/session-history-adapters/omp.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { HOME_DIR } = require('../../../config/paths');
+const { getOmpPaths } = require('../omp-config');
+
+function getOmpSessionPaths() {
+  return getOmpPaths(process.env, { resolveRuntime: false });
+}
+
+function encodeProjectName(cwd = '') {
+  return `--${String(cwd || '').replace(/\\/g, '/').replace(/\//g, '--')}--`;
+}
+
+function getDisplayName(cwd = '') {
+  const normalized = String(cwd || '').trim();
+  if (!normalized) return 'Unknown';
+  return path.basename(normalized) || normalized;
+}
+
+function parseOmpSessionId(filePath = '') {
+  const base = path.basename(filePath, '.jsonl');
+  const match = base.match(/([0-9a-f]{8}-[0-9a-f-]{8,})$/i);
+  if (match) return match[1];
+  return base;
+}
+
+function normalizeTextContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === 'string') return item;
+      if (item?.type === 'text') return item.text || '';
+      if (item?.text) return item.text;
+      return '';
+    }).filter(Boolean).join('\n');
+  }
+  if (content && typeof content === 'object') {
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.content === 'string') return content.content;
+  }
+  return '';
+}
+
+function extractMessageText(message = {}) {
+  if (typeof message.content === 'string' || Array.isArray(message.content)) {
+    return normalizeTextContent(message.content);
+  }
+  if (Array.isArray(message.parts)) {
+    return normalizeTextContent(message.parts);
+  }
+  if (Array.isArray(message.thinking)) {
+    return normalizeTextContent(message.thinking);
+  }
+  if (message.toolCall && typeof message.toolCall === 'object') {
+    return JSON.stringify(message.toolCall, null, 2);
+  }
+  if (message.toolResult && typeof message.toolResult === 'object') {
+    return normalizeTextContent(message.toolResult.content || message.toolResult.output || message.toolResult);
+  }
+  if (message.bashExecution && typeof message.bashExecution === 'object') {
+    return normalizeTextContent(message.bashExecution.output || message.bashExecution.command || message.bashExecution);
+  }
+  if (typeof message.text === 'string') return message.text;
+  if (typeof message.output === 'string') return message.output;
+  return '';
+}
+
+function parseUsage(usage = {}) {
+  const input = Number(usage.input ?? usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens ?? usage.promptTokens ?? 0) || 0;
+  const output = Number(usage.output ?? usage.outputTokens ?? usage.output_tokens ?? usage.completion_tokens ?? usage.completionTokens ?? 0) || 0;
+  const cacheRead = Number(usage.cacheRead ?? usage.cache_read ?? usage.cachedTokens ?? usage.cached_tokens ?? usage.cache_read_input_tokens ?? 0) || 0;
+  const cacheWrite = Number(usage.cacheWrite ?? usage.cache_write ?? usage.cacheCreation ?? usage.cache_creation ?? usage.cache_creation_input_tokens ?? 0) || 0;
+  const reasoning = Number(usage.reasoningTokens ?? usage.reasoning_tokens ?? 0) || 0;
+  const total = Number(usage.totalTokens ?? usage.total_tokens ?? (input + output + cacheRead + cacheWrite + reasoning)) || 0;
+  const cost = typeof usage.cost === 'number'
+    ? usage.cost
+    : Number(usage.cost?.total ?? usage.cost?.usd ?? 0) || 0;
+  return { input, output, cached: cacheRead, cacheRead, cacheWrite, reasoning, total, cost };
+}
+
+function readJsonLines(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw
+      .split(/\r?\n/)
+      .filter(line => line.trim())
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return { type: 'invalid', raw: line };
+        }
+      });
+  } catch {
+    return [];
+  }
+}
+
+function convertOmpEntry(entry = {}, index = 0) {
+  if (!entry || entry.type !== 'message') {
+    return null;
+  }
+  const message = entry.message || {};
+  const role = message.role || entry.role;
+  const assistantLikeRoles = new Set(['assistant', 'tool', 'toolResult', 'tool_result', 'bashExecution', 'bash_execution', 'custom']);
+  if (role !== 'user' && !assistantLikeRoles.has(role)) {
+    return null;
+  }
+  const text = extractMessageText(message);
+  const type = role === 'user' ? 'user' : 'assistant';
+  const result = {
+    id: entry.id || message.id || `msg-${index}`,
+    type,
+    role,
+    content: text || '',
+    timestamp: entry.timestamp || message.timestamp || null
+  };
+
+  if (type === 'assistant') {
+    if (role !== 'assistant') {
+      result.subtype = role;
+    }
+    result.provider = entry.provider || message.provider || '';
+    result.model = entry.model || message.model || '';
+    result.usage = parseUsage(entry.usage || message.usage || {});
+  }
+
+  return result;
+}
+
+/**
+ * Inventory all OMP session files.
+ * @returns {Promise<Array>}
+ */
+async function inventory() {
+  const descriptors = [];
+  let sessionsDir;
+  try {
+    sessionsDir = getOmpSessionPaths().sessions;
+  } catch (_) {
+    return descriptors;
+  }
+  if (!fs.existsSync(sessionsDir)) return descriptors;
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        try {
+          const stat = fs.statSync(fullPath);
+          descriptors.push({
+            filePath: fullPath,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            sessionId: parseOmpSessionId(fullPath),
+            projectHint: null // OMP determines project from session content
+          });
+        } catch (_) {}
+      }
+    }
+  }
+
+  walk(sessionsDir);
+  return descriptors;
+}
+
+/**
+ * Parse an OMP session file.
+ */
+async function parse(descriptor) {
+  const { filePath, size, mtimeMs } = descriptor;
+  const entries = readJsonLines(filePath);
+  const header = entries.find(entry => entry?.type === 'session') || {};
+  const cwd = header.cwd || '';
+  const sessionId = header.id || parseOmpSessionId(filePath) || descriptor.sessionId;
+
+  const parsedMessages = entries.map((entry, idx) => convertOmpEntry(entry, idx)).filter(Boolean);
+
+  // Find model change
+  const modelChange = [...entries].reverse().find(entry => entry?.type === 'model_change');
+  const model = modelChange?.modelId || modelChange?.model || parsedMessages.find(m => m.type === 'assistant' && m.model)?.model || null;
+  const provider = modelChange?.provider || parsedMessages.find(m => m.type === 'assistant' && m.provider)?.provider || null;
+
+  // Aggregate usage
+  const usage = parsedMessages
+    .filter(m => m.type === 'assistant')
+    .reduce((acc, m) => {
+      const u = parseUsage(m.usage || {});
+      acc.input += u.input;
+      acc.output += u.output;
+      acc.cached += u.cached;
+      acc.reasoning += u.reasoning;
+      acc.total += u.total;
+      acc.cost += u.cost || 0;
+      return acc;
+    }, { input: 0, output: 0, cached: 0, reasoning: 0, total: 0, cost: 0 });
+
+  const usageJson = JSON.stringify(usage);
+
+  // Normalize messages
+  const messages = [];
+  let userMessageNumber = 0;
+  for (const pm of parsedMessages) {
+    const msg = {
+      messageId: pm.id || null,
+      role: pm.type === 'user' ? 'user' : 'assistant',
+      type: pm.type,
+      subtype: pm.subtype || null,
+      content: typeof pm.content === 'string' ? pm.content : '',
+      timestamp: pm.timestamp ? (typeof pm.timestamp === 'number' ? pm.timestamp : new Date(pm.timestamp).getTime()) : null,
+      model: pm.model || model || null,
+      provider: pm.provider || provider || null,
+      userMessageNumber: null,
+      extraJson: null
+    };
+    if (msg.role === 'user') {
+      userMessageNumber++;
+      msg.userMessageNumber = userMessageNumber;
+    }
+    messages.push(msg);
+  }
+
+  const firstUserMsg = messages.find(m => m.role === 'user' && m.content);
+  const lastMsg = messages[messages.length - 1];
+  const projectName = cwd ? encodeProjectName(cwd) : 'unknown';
+  const displayName = getDisplayName(cwd);
+
+  const session = {
+    sessionId,
+    projectName,
+    projectDisplayName: displayName,
+    projectFullPath: cwd || null,
+    firstMessage: firstUserMsg ? firstUserMsg.content : null,
+    gitBranch: header.gitBranch || null,
+    provider,
+    model,
+    startedAt: messages[0] ? messages[0].timestamp : null,
+    updatedAt: lastMsg ? (lastMsg.timestamp || mtimeMs) : mtimeMs,
+    usageJson,
+    extraJson: JSON.stringify({ cwd })
+  };
+
+  return { session, messages };
+}
+
+module.exports = { inventory, parse, convertOmpEntry, parseUsage, encodeProjectName: encodeProjectName, getDisplayName, readJsonLines, extractMessageText, normalizeTextContent };