memhouse 0.0.1 → 0.3.1

package/editors/gemini.js

@@ -0,0 +1,231 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const GEMINI_DIR = path.join(os.homedir(), '.gemini');
+const TMP_DIR = path.join(GEMINI_DIR, 'tmp');
+const PROJECTS_JSON = path.join(GEMINI_DIR, 'projects.json');
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'gemini-cli';
+
+/**
+ * Load project path mapping from ~/.gemini/projects.json
+ * Format: { "projects": { "/Users/dev/Code/myapp": "myapp" } }
+ * Returns Map<projectName, folderPath>
+ */
+function loadProjectMap() {
+  const map = new Map();
+  try {
+    const data = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    if (data.projects) {
+      for (const [folderPath, projName] of Object.entries(data.projects)) {
+        map.set(projName, folderPath);
+      }
+    }
+  } catch {}
+  return map;
+}
+
+/**
+ * Load a Gemini session record, handling BOTH on-disk formats:
+ *  - legacy single-object JSON: { sessionId, startTime, lastUpdated, messages: [...] }
+ *  - newer .jsonl oplog: a header line, then interleaved message objects and
+ *    {$set:{messages:[...]}} snapshots. Reconstruct = the latest messages snapshot
+ *    (they accumulate) plus any message objects appended after it.
+ * Returns { sessionId, startTime, lastUpdated, messages }.
+ */
+function loadGeminiRecord(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  if (!filePath.endsWith('.jsonl')) {
+    const rec = JSON.parse(raw);
+    return { sessionId: rec.sessionId, startTime: rec.startTime, lastUpdated: rec.lastUpdated, messages: rec.messages || [] };
+  }
+  let header = {}, messages = null, tail = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let o; try { o = JSON.parse(line); } catch { continue; }
+    if (o.$set) {
+      if (Array.isArray(o.$set.messages)) { messages = o.$set.messages; tail = []; }
+      if (o.$set.lastUpdated) header.lastUpdated = o.$set.lastUpdated;
+    } else if (o.type && o.content !== undefined) {
+      tail.push(o); // message appended after the last snapshot
+    } else if (o.sessionId || o.startTime) {
+      header = { ...header, ...o }; // header/meta line
+    }
+  }
+  return {
+    sessionId: header.sessionId,
+    startTime: header.startTime,
+    lastUpdated: header.lastUpdated,
+    messages: (messages || []).concat(tail),
+  };
+}
+
+function getChats() {
+  const chats = [];
+  if (!fs.existsSync(TMP_DIR)) return chats;
+
+  const projectMap = loadProjectMap();
+
+  // Each subdirectory under tmp/ is a project name (e.g. "codename-share")
+  let projectDirs;
+  try { projectDirs = fs.readdirSync(TMP_DIR); } catch { return chats; }
+
+  for (const projName of projectDirs) {
+    const projDir = path.join(TMP_DIR, projName);
+    try { if (!fs.statSync(projDir).isDirectory()) continue; } catch { continue; }
+
+    // Sessions are in <projDir>/chats/session-*.json
+    const chatsDir = path.join(projDir, 'chats');
+    if (!fs.existsSync(chatsDir)) continue;
+
+    let files;
+    try {
+      // Both formats: legacy session-*.json + newer session-*.jsonl (oplog).
+      // The chats/<uuid>/ checkpoint subdirs are skipped (not session- prefixed).
+      files = fs.readdirSync(chatsDir).filter(f => f.startsWith('session-') && (f.endsWith('.json') || f.endsWith('.jsonl')));
+    } catch { continue; }
+
+    // Resolve folder from projects.json mapping
+    const folder = projectMap.get(projName) || null;
+
+    for (const file of files) {
+      const fullPath = path.join(chatsDir, file);
+      try {
+        const record = loadGeminiRecord(fullPath);
+        if (!record || !record.messages || record.messages.length === 0) continue;
+
+        const sessionId = record.sessionId || file.replace(/\.jsonl?$/, '');
+        const messages = record.messages;
+
+        // Extract first user prompt for title
+        const firstUser = messages.find(m => m.type === 'user');
+        const firstPrompt = extractTextContent(firstUser?.content);
+
+        chats.push({
+          source: 'gemini-cli',
+          composerId: sessionId,
+          name: firstPrompt ? cleanPrompt(firstPrompt) : null,
+          createdAt: record.startTime ? new Date(record.startTime).getTime() : null,
+          lastUpdatedAt: record.lastUpdated ? new Date(record.lastUpdated).getTime() : null,
+          mode: 'gemini',
+          folder,
+          encrypted: false,
+          bubbleCount: messages.length,
+          _fullPath: fullPath,
+        });
+      } catch { /* skip malformed files */ }
+    }
+  }
+
+  return chats;
+}
+
+function cleanPrompt(text) {
+  if (!text) return null;
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120) || null;
+}
+
+function extractTextContent(content) {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  // Array of { text } parts (user messages)
+  if (Array.isArray(content)) {
+    return content
+      .filter(p => p.text)
+      .map(p => p.text)
+      .join('\n') || '';
+  }
+  if (content.text) return content.text;
+  return '';
+}
+
+function getMessages(chat) {
+  const filePath = chat._fullPath;
+  if (!filePath || !fs.existsSync(filePath)) return [];
+
+  let record;
+  try {
+    record = loadGeminiRecord(filePath);
+  } catch { return []; }
+
+  if (!record || !record.messages) return [];
+
+  const result = [];
+  for (const msg of record.messages) {
+    const type = msg.type;
+    const text = extractTextContent(msg.content || msg.displayContent);
+
+    if (type === 'user') {
+      if (text) result.push({ role: 'user', content: text });
+    } else if (type === 'gemini') {
+      const parts = [];
+      const toolCalls = [];
+
+      // Thoughts have { subject, description, timestamp }
+      if (msg.thoughts && Array.isArray(msg.thoughts)) {
+        for (const t of msg.thoughts) {
+          const thought = t.description || t.subject || '';
+          if (thought) parts.push(`[thinking] ${thought}`);
+        }
+      }
+
+      // Main text content (string for gemini messages)
+      if (text) parts.push(text);
+
+      // Tool calls
+      if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
+        for (const tc of msg.toolCalls) {
+          const args = tc.args || {};
+          const argKeys = typeof args === 'object' ? Object.keys(args).join(', ') : '';
+          parts.push(`[tool-call: ${tc.name || 'unknown'}(${argKeys})]`);
+          toolCalls.push({ name: tc.name || 'unknown', args });
+        }
+      }
+
+      if (parts.length > 0) {
+        const tokens = msg.tokens || {};
+        result.push({
+          role: 'assistant',
+          content: parts.join('\n'),
+          _model: msg.model,
+          _inputTokens: tokens.input,
+          _outputTokens: tokens.output,
+          _cacheRead: tokens.cached,
+          _toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+      }
+    } else if (type === 'info' || type === 'error' || type === 'warning') {
+      if (text) result.push({ role: 'system', content: `[${type}] ${text}` });
+    }
+  }
+
+  return result;
+}
+
+const labels = { 'gemini-cli': 'Gemini CLI' };
+
+function getArtifacts(folder) {
+  const { scanArtifacts } = require('./base');
+  return scanArtifacts(folder, {
+    editor: 'gemini-cli',
+    label: 'Gemini CLI',
+    files: ['GEMINI.md'],
+    dirs: [],
+  });
+}
+
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  // Global: ~/.gemini/settings.json (mcpServers key)
+  const globalSettings = path.join(os.homedir(), '.gemini', 'settings.json');
+  return [
+    ...parseMcpConfigFile(globalSettings, { editor: 'gemini-cli', label: 'Gemini CLI', scope: 'global' }),
+  ];
+}
+
+module.exports = { name, labels, getChats, getMessages, getArtifacts, getMCPServers };

package/editors/goose.js

@@ -0,0 +1,386 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const adapterErrors = require('./adapter-errors');
+
+const GOOSE_DIR = path.join(os.homedir(), '.local', 'share', 'goose', 'sessions');
+const DB_PATH = path.join(GOOSE_DIR, 'sessions.db');
+const CONFIG_PATH = path.join(os.homedir(), '.config', 'goose', 'config.yaml');
+
+// ============================================================
+// Query SQLite via better-sqlite3 (cross-platform)
+// ============================================================
+
+let Database;
+function getDatabase() {
+  if (!Database) {
+    try {
+      Database = require('better-sqlite3');
+    } catch {
+      // better-sqlite3 not available
+    }
+  }
+  return Database;
+}
+
+function queryDb(sql) {
+  if (!fs.existsSync(DB_PATH)) return [];
+  const Db = getDatabase();
+  if (!Db) {
+    adapterErrors.record('goose', new Error('better-sqlite3 unavailable'), DB_PATH);
+    return [];
+  }
+  try {
+    const db = new Db(DB_PATH, { readonly: true });
+    const rows = db.prepare(sql).all();
+    db.close();
+    return rows;
+  } catch (e) {
+    adapterErrors.record('goose', e, DB_PATH);
+    return [];
+  }
+}
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'goose';
+
+let _configModel = undefined; // lazy-loaded
+
+function getConfigModel() {
+  if (_configModel !== undefined) return _configModel;
+  _configModel = null;
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    const modelMatch = raw.match(/^GOOSE_MODEL:\s*(.+)$/m);
+    if (modelMatch) _configModel = modelMatch[1].trim();
+  } catch {}
+  return _configModel;
+}
+
+function getChats() {
+  const chats = [];
+
+  const configModel = getConfigModel();
+
+  // --- SQLite sessions (v1.10.0+) ---
+  const dbSessions = queryDb(
+    `SELECT id, name, description, working_dir, created_at, updated_at,
+            total_tokens, input_tokens, output_tokens, provider_name, model_config_json,
+            (SELECT count(*) FROM messages m WHERE m.session_id = s.id) as msg_count
+     FROM sessions s ORDER BY updated_at DESC`
+  );
+
+  const dbSessionIds = new Set();
+  for (const row of dbSessions) {
+    dbSessionIds.add(row.id);
+    chats.push({
+      source: 'goose',
+      composerId: row.id,
+      name: cleanTitle(row.name || row.description),
+      createdAt: parseTimestamp(row.created_at),
+      lastUpdatedAt: parseTimestamp(row.updated_at),
+      mode: 'goose',
+      folder: row.working_dir || null,
+      encrypted: false,
+      bubbleCount: row.msg_count || 0,
+      _storage: 'db',
+      _inputTokens: row.input_tokens,
+      _outputTokens: row.output_tokens,
+      _model: extractSessionModel(row) || configModel,
+    });
+  }
+
+  // --- Legacy JSONL files ---
+  if (fs.existsSync(GOOSE_DIR)) {
+    let files;
+    // The directory exists (checked above); if it will not enumerate, every legacy
+    // jsonl session disappears at discovery and nothing downstream can miss what it
+    // never saw.
+    try { files = fs.readdirSync(GOOSE_DIR).filter(f => f.endsWith('.jsonl')); }
+    catch (e) { adapterErrors.record('goose', e, GOOSE_DIR); files = []; }
+
+    for (const file of files) {
+      const sessionId = file.replace('.jsonl', '');
+      if (dbSessionIds.has(sessionId)) continue; // already in DB
+
+      const fullPath = path.join(GOOSE_DIR, file);
+      try {
+        const stat = fs.statSync(fullPath);
+        const meta = peekJsonlMeta(fullPath);
+        chats.push({
+          source: 'goose',
+          composerId: sessionId,
+          name: meta.firstPrompt ? cleanTitle(meta.firstPrompt) : null,
+          createdAt: meta.timestamp || stat.birthtime.getTime(),
+          lastUpdatedAt: stat.mtime.getTime(),
+          mode: 'goose',
+          folder: meta.workingDir || null,
+          encrypted: false,
+          _storage: 'jsonl',
+          _fullPath: fullPath,
+          _model: configModel,
+        });
+      } catch (e) {
+        // Same shape one level down: an unstattable or unparseable session file is
+        // omitted from the listing entirely, so it is invisible to doctor and the
+        // shipper alike.
+        adapterErrors.record('goose', e, fullPath);
+      }
+    }
+  }
+
+  return chats;
+}
+
+function parseTimestamp(ts) {
+  if (!ts) return null;
+  if (typeof ts === 'number') return ts;
+  const d = new Date(ts);
+  return isNaN(d.getTime()) ? null : d.getTime();
+}
+
+function cleanTitle(title) {
+  if (!title) return null;
+  return title.substring(0, 120).trim() || null;
+}
+
+function peekJsonlMeta(filePath) {
+  const meta = { firstPrompt: null, workingDir: null, timestamp: null };
+  try {
+    const buf = fs.readFileSync(filePath, 'utf-8');
+    for (const line of buf.split('\n')) {
+      if (!line) continue;
+      const obj = JSON.parse(line);
+
+      if (!meta.timestamp && obj.created) {
+        meta.timestamp = parseTimestamp(obj.created);
+      }
+
+      if (!meta.workingDir && obj.working_dir) {
+        meta.workingDir = obj.working_dir;
+      }
+
+      // First user text message
+      if (!meta.firstPrompt && obj.role === 'user' && obj.content) {
+        let parts;
+        try { parts = typeof obj.content === 'string' ? JSON.parse(obj.content) : obj.content; } catch { continue; }
+        if (Array.isArray(parts)) {
+          const text = parts.filter(p => p.type === 'text').map(p => p.text).join(' ');
+          if (text) meta.firstPrompt = text.substring(0, 200);
+        }
+      }
+
+      if (meta.firstPrompt && meta.workingDir) break;
+    }
+  } catch {}
+  return meta;
+}
+
+function getMessages(chat) {
+  if (chat._storage === 'db') return getMessagesFromDb(chat);
+  if (chat._storage === 'jsonl') return getMessagesFromJsonl(chat);
+  // Try DB first, then JSONL
+  const dbMessages = getMessagesFromDb(chat);
+  if (dbMessages.length) return dbMessages;
+  return getMessagesFromJsonl(chat);
+}
+
+function getMessagesFromDb(chat) {
+  const rows = queryDb(
+    `SELECT role, content_json, created_timestamp FROM messages
+     WHERE session_id = '${chat.composerId}' ORDER BY created_timestamp ASC`
+  );
+
+  const result = [];
+  for (const row of rows) {
+    let parts;
+    // A row we cannot decode drops a message from the transcript. Silently, that is
+    // a truncation that looks complete, and a re-ship would replace the stored
+    // transcript with it. Report so the shipper withholds and retries instead.
+    try { parts = JSON.parse(row.content_json); }
+    catch (e) { adapterErrors.record('goose', e, `session ${chat.composerId}`); continue; }
+    if (!Array.isArray(parts)) {
+      adapterErrors.record('goose', new Error('message content_json is not an array'), `session ${chat.composerId}`);
+      continue;
+    }
+
+    const role = row.role;
+    const contentParts = [];
+    const toolCalls = [];
+
+    for (const part of parts) {
+      if (part.type === 'text' && part.text) {
+        contentParts.push(part.text);
+      } else if (part.type === 'toolRequest' && part.toolCall) {
+        const tc = part.toolCall.value || {};
+        const toolName = tc.name || 'tool';
+        let argKeys = '';
+        try { argKeys = Object.keys(tc.arguments || {}).join(', '); } catch {}
+        contentParts.push(`[tool-call: ${toolName}(${argKeys})]`);
+        toolCalls.push({ name: toolName, args: tc.arguments || {} });
+      } else if (part.type === 'toolResponse' && part.toolResult) {
+        const tr = part.toolResult;
+        let preview = '';
+        if (tr.value && Array.isArray(tr.value)) {
+          preview = tr.value
+            .filter(v => v.type === 'text')
+            .map(v => v.text)
+            .join('\n')
+            .substring(0, 500);
+        }
+        contentParts.push(`[tool-result: ${tr.status || 'done'}] ${preview}`);
+      }
+    }
+
+    const content = contentParts.join('\n');
+    if (!content) continue;
+
+    const mappedRole = role === 'user' ? 'user' : role === 'assistant' ? 'assistant' : role;
+    const msg = { role: mappedRole, content };
+    if (mappedRole === 'assistant' && chat._model) msg._model = chat._model;
+    if (toolCalls.length) msg._toolCalls = toolCalls;
+    result.push(msg);
+  }
+
+  return result;
+}
+
+function getMessagesFromJsonl(chat) {
+  const filePath = chat._fullPath || path.join(GOOSE_DIR, chat.composerId + '.jsonl');
+  if (!fs.existsSync(filePath)) return [];
+
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+  const result = [];
+
+  for (const line of lines) {
+    let obj;
+    // The legacy JSONL store needs the same protection as the SQLite one: a corrupt
+    // line drops a message, and the truncated transcript would overwrite the stored
+    // one when the file's mtime changes or --full is used.
+    try { obj = JSON.parse(line); }
+    catch (e) { adapterErrors.record('goose', e, filePath); continue; }
+
+    if (!obj.role) continue;
+
+    let parts;
+    try {
+      parts = typeof obj.content === 'string' ? JSON.parse(obj.content) : obj.content;
+    } catch {
+      // content might be plain text
+      if (typeof obj.content === 'string' && obj.content) {
+        result.push({ role: obj.role, content: obj.content });
+      }
+      continue;
+    }
+
+    if (!Array.isArray(parts)) continue;
+
+    const contentParts = [];
+    for (const part of parts) {
+      if (part.type === 'text' && part.text) {
+        contentParts.push(part.text);
+      } else if (part.type === 'toolRequest') {
+        const tc = part.toolCall?.value || {};
+        contentParts.push(`[tool-call: ${tc.name || 'tool'}(${Object.keys(tc.arguments || {}).join(', ')})]`);
+      } else if (part.type === 'toolResponse') {
+        const tr = part.toolResult || {};
+        let preview = '';
+        if (Array.isArray(tr.value)) {
+          preview = tr.value.filter(v => v.type === 'text').map(v => v.text).join('\n').substring(0, 500);
+        }
+        contentParts.push(`[tool-result] ${preview}`);
+      }
+    }
+
+    const content = contentParts.join('\n');
+    if (content) {
+      const msg = { role: obj.role, content };
+      if (obj.role === 'assistant' && chat._model) msg._model = chat._model;
+      result.push(msg);
+    }
+  }
+
+  return result;
+}
+
+function extractSessionModel(row) {
+  if (row.model_config_json) {
+    try {
+      const cfg = JSON.parse(row.model_config_json);
+      if (cfg.model) return cfg.model;
+      if (cfg.model_id) return cfg.model_id;
+    } catch {}
+  }
+  return null;
+}
+
+function resetCache() {
+  _configModel = undefined;
+}
+
+const labels = { 'goose': 'Goose' };
+
+function getArtifacts(folder) {
+  const { scanArtifacts } = require('./base');
+  return scanArtifacts(folder, {
+    editor: 'goose',
+    label: 'Goose',
+    files: ['.goosehints'],
+    dirs: [],
+  });
+}
+
+function getMCPServers() {
+  const results = [];
+  // Goose stores MCP config in ~/.config/goose/config.yaml under extensions
+  // Also check profiles.yaml for MCP server entries
+  const configFiles = [CONFIG_PATH, path.join(os.homedir(), '.config', 'goose', 'profiles.yaml')];
+  for (const cfgPath of configFiles) {
+    if (!fs.existsSync(cfgPath)) continue;
+    try {
+      const raw = fs.readFileSync(cfgPath, 'utf-8');
+      // Simple YAML parsing for mcpServers / extensions blocks
+      let currentServer = null;
+      let inMcp = false;
+      for (const line of raw.split('\n')) {
+        if (line.match(/^\s*(mcpServers|extensions):/)) { inMcp = true; continue; }
+        if (inMcp && line.match(/^\s{2}\w/) && !line.match(/^\s{4}/)) {
+          // New top-level key under mcpServers
+          if (currentServer) results.push(currentServer);
+          const nameMatch = line.match(/^\s{2}(\S+):/);
+          if (nameMatch) {
+            currentServer = {
+              name: nameMatch[1],
+              editor: 'goose',
+              editorLabel: 'Goose',
+              scope: 'global',
+              configPath: cfgPath,
+              command: null, args: [], env: [], url: null,
+              transport: 'stdio', disabled: false, disabledTools: [],
+            };
+          }
+          continue;
+        }
+        if (inMcp && currentServer) {
+          const cmdMatch = line.match(/^\s+command:\s*(.+)/);
+          if (cmdMatch) currentServer.command = cmdMatch[1].trim();
+          const urlMatch = line.match(/^\s+url:\s*(.+)/);
+          if (urlMatch) { currentServer.url = urlMatch[1].trim(); currentServer.transport = 'http'; }
+        }
+        if (line.match(/^\S/) && !line.match(/^\s/) && inMcp) {
+          if (currentServer) results.push(currentServer);
+          currentServer = null;
+          inMcp = false;
+        }
+      }
+      if (currentServer) results.push(currentServer);
+    } catch {}
+  }
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, resetCache, getArtifacts, getMCPServers };