memhouse 0.0.1 → 0.3.0

package/editors/copilot-jetbrains.js

@@ -0,0 +1,207 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const JB_DIR = path.join(os.homedir(), '.copilot', 'jb');
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'copilot-jetbrains';
+
+/**
+ * Parse partition-*.jsonl files from a JetBrains Copilot session directory.
+ * Each line is one JSON event; partition-<N>.jsonl files are read in order.
+ */
+function parseEvents(sessionDir) {
+  let entries;
+  try { entries = fs.readdirSync(sessionDir); } catch { return []; }
+  const partitions = entries
+    .filter(f => /^partition-\d+\.jsonl$/.test(f))
+    .sort((a, b) =>
+      parseInt(a.match(/^partition-(\d+)\.jsonl$/)[1], 10) -
+      parseInt(b.match(/^partition-(\d+)\.jsonl$/)[1], 10));
+
+  const events = [];
+  for (const p of partitions) {
+    try {
+      const raw = fs.readFileSync(path.join(sessionDir, p), 'utf-8');
+      for (const line of raw.split('\n')) {
+        if (!line.trim()) continue;
+        try { events.push(JSON.parse(line)); } catch { /* skip malformed */ }
+      }
+    } catch { /* skip unreadable partition */ }
+  }
+  return events;
+}
+
+/**
+ * Parse a JetBrains event `timestamp` field to epoch ms.
+ * Handles ISO 8601 and the US-locale `MM/dd/yyyy HH:mm:ss` format emitted by
+ * the JetBrains plugin.
+ */
+function parseTimestamp(ts) {
+  if (!ts) return null;
+  const str = String(ts);
+  if (str.includes('T')) {
+    const t = Date.parse(str);
+    if (!Number.isNaN(t)) return t;
+  }
+  const m = str.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})\s+(\d{1,2}):(\d{2}):(\d{2})$/);
+  if (m) return Date.UTC(+m[3], +m[1] - 1, +m[2], +m[4], +m[5], +m[6]);
+  return null;
+}
+
+function getChats() {
+  const chats = [];
+  if (!fs.existsSync(JB_DIR)) return chats;
+
+  let sessionDirs;
+  try { sessionDirs = fs.readdirSync(JB_DIR); } catch { return chats; }
+
+  for (const dirName of sessionDirs) {
+    const sessionDir = path.join(JB_DIR, dirName);
+    try { if (!fs.statSync(sessionDir).isDirectory()) continue; } catch { continue; }
+
+    const events = parseEvents(sessionDir);
+    const userMessages = events.filter(e => e.type === 'user.message');
+    const assistantMessages = events.filter(e => e.type === 'assistant.message');
+    const firstUser = userMessages[0];
+
+    // Count meaningful messages (user + assistant)
+    const bubbleCount = userMessages.length + assistantMessages.length;
+    if (bubbleCount === 0) continue;
+
+    let createdAt = null, lastUpdatedAt = null;
+    for (const e of events) {
+      const t = parseTimestamp(e.timestamp);
+      if (t == null) continue;
+      if (createdAt == null || t < createdAt) createdAt = t;
+      if (lastUpdatedAt == null || t > lastUpdatedAt) lastUpdatedAt = t;
+    }
+
+    chats.push({
+      source: 'copilot-jetbrains',
+      composerId: dirName,
+      name: cleanPrompt(firstUser?.data?.content),
+      createdAt,
+      lastUpdatedAt,
+      mode: 'copilot',
+      folder: null,
+      encrypted: false,
+      bubbleCount,
+      _sessionDir: sessionDir,
+    });
+  }
+
+  return chats;
+}
+
+function cleanPrompt(text) {
+  if (!text) return null;
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120) || null;
+}
+
+function getMessages(chat) {
+  const sessionDir = chat._sessionDir;
+  if (!sessionDir || !fs.existsSync(sessionDir)) return [];
+
+  const events = parseEvents(sessionDir);
+  const result = [];
+
+  // Tool calls in the JetBrains format are separate `tool.execution_start` /
+  // `tool.execution_complete` events (NOT embedded in assistant.message like
+  // the CLI format). Buffer pending tool calls and attach them to the next
+  // assistant message iteration, per the spec's grouping algorithm.
+  const pendingToolCalls = [];
+
+  for (const event of events) {
+    if (event.type === 'user.message') {
+      const content = extractContent(event.data?.content);
+      if (content) result.push({ role: 'user', content });
+
+    } else if (event.type === 'tool.execution_start') {
+      const data = event.data || {};
+      const tcName = data.toolName || 'unknown';
+      const args = data.arguments || {};
+      const parsedArgs = typeof args === 'string' ? safeParse(args) : args;
+      pendingToolCalls.push({ name: tcName, args: parsedArgs });
+
+    } else if (event.type === 'assistant.message') {
+      const data = event.data || {};
+      const parts = [];
+      const toolCalls = pendingToolCalls.length > 0 ? pendingToolCalls.splice(0) : [];
+
+      // Main text content — handle legacy double-encoded JSON array shape.
+      const text = extractContent(data.content != null ? data.content : data.text);
+      if (text) parts.push(text);
+
+      // Render buffered tool calls inline for compactness.
+      for (const tc of toolCalls) {
+        const argKeys = typeof tc.args === 'object' ? Object.keys(tc.args).join(', ') : '';
+        parts.push(`[tool-call: ${tc.name}(${argKeys})]`);
+      }
+
+      if (parts.length > 0) {
+        result.push({
+          role: 'assistant',
+          content: parts.join('\n'),
+          _toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+      }
+    }
+  }
+
+  // Flush any tool calls left dangling (turn ended without a final assistant.message).
+  if (pendingToolCalls.length > 0) {
+    const parts = pendingToolCalls.map(tc => {
+      const argKeys = typeof tc.args === 'object' ? Object.keys(tc.args).join(', ') : '';
+      return `[tool-call: ${tc.name}(${argKeys})]`;
+    });
+    result.push({
+      role: 'assistant',
+      content: parts.join('\n'),
+      _toolCalls: pendingToolCalls.splice(0),
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Extract assistant response text from a `data.content` value.
+ * Handles plain strings and the legacy double-encoded JSON array shape
+ * (older partitions store content as a stringified array of
+ * {role, content, tool_calls} objects — pick the last role:assistant
+ * entry with non-empty content).
+ */
+function extractContent(contentVal) {
+  if (contentVal == null) return '';
+  if (typeof contentVal === 'string') {
+    const trimmed = contentVal.trim();
+    if (trimmed.startsWith('[')) {
+      try {
+        const arr = JSON.parse(contentVal);
+        if (Array.isArray(arr)) {
+          for (let i = arr.length - 1; i >= 0; i--) {
+            const el = arr[i];
+            if (el && el.role === 'assistant' && el.content) {
+              return typeof el.content === 'string' ? el.content : extractContent(el.content);
+            }
+          }
+        }
+      } catch { /* fall through to raw string */ }
+    }
+    return contentVal;
+  }
+  return '';
+}
+
+function safeParse(str) {
+  try { return JSON.parse(str); } catch { return {}; }
+}
+
+const labels = { 'copilot-jetbrains': 'GitHub Copilot - JetBrains' };
+
+module.exports = { name, labels, getChats, getMessages };

package/editors/copilot.js

@@ -0,0 +1,260 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const COPILOT_DIR = path.join(os.homedir(), '.copilot');
+const SESSION_STATE_DIR = path.join(COPILOT_DIR, 'session-state');
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'copilot-cli';
+
+/**
+ * Parse workspace.yaml from a session directory.
+ * Fields: id, cwd, git_root, repository, branch, summary, created_at, updated_at
+ */
+function parseWorkspace(sessionDir) {
+  const yamlPath = path.join(sessionDir, 'workspace.yaml');
+  if (!fs.existsSync(yamlPath)) return null;
+  try {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    // Simple YAML parsing — handle key: value lines
+    const meta = {};
+    for (const line of raw.split('\n')) {
+      const match = line.match(/^(\w+):\s*(.*)$/);
+      if (match) meta[match[1]] = match[2].trim();
+    }
+    return meta;
+  } catch { return null; }
+}
+
+/**
+ * Parse events.jsonl and extract user/assistant messages.
+ * Event types: session.start, user.message, assistant.message,
+ *   assistant.turn_start, assistant.turn_end, session.shutdown
+ */
+function parseEvents(sessionDir) {
+  const eventsPath = path.join(sessionDir, 'events.jsonl');
+  if (!fs.existsSync(eventsPath)) return [];
+  try {
+    const raw = fs.readFileSync(eventsPath, 'utf-8');
+    return raw.split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function getChats() {
+  const chats = [];
+  if (!fs.existsSync(SESSION_STATE_DIR)) return chats;
+
+  let sessionDirs;
+  try { sessionDirs = fs.readdirSync(SESSION_STATE_DIR); } catch { return chats; }
+
+  for (const dirName of sessionDirs) {
+    const sessionDir = path.join(SESSION_STATE_DIR, dirName);
+    try { if (!fs.statSync(sessionDir).isDirectory()) continue; } catch { continue; }
+
+    const meta = parseWorkspace(sessionDir);
+    if (!meta) continue;
+
+    const events = parseEvents(sessionDir);
+    const userMessages = events.filter(e => e.type === 'user.message');
+    const assistantMessages = events.filter(e => e.type === 'assistant.message');
+    const firstUser = userMessages[0];
+
+    // Count meaningful messages (user + assistant)
+    const bubbleCount = userMessages.length + assistantMessages.length;
+    if (bubbleCount === 0) continue;
+
+    // Extract model from shutdown event or assistant messages
+    const shutdown = events.find(e => e.type === 'session.shutdown');
+    const model = shutdown?.data?.currentModel || null;
+
+    chats.push({
+      source: 'copilot-cli',
+      composerId: meta.id || dirName,
+      name: meta.summary || cleanPrompt(firstUser?.data?.content),
+      createdAt: meta.created_at ? new Date(meta.created_at).getTime() : null,
+      lastUpdatedAt: meta.updated_at ? new Date(meta.updated_at).getTime() : null,
+      mode: 'copilot',
+      folder: meta.cwd || meta.git_root || null,
+      encrypted: false,
+      bubbleCount,
+      _sessionDir: sessionDir,
+      _model: model,
+      _shutdownData: shutdown?.data || null,
+    });
+  }
+
+  return chats;
+}
+
+function cleanPrompt(text) {
+  if (!text) return null;
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120) || null;
+}
+
+function getMessages(chat) {
+  const sessionDir = chat._sessionDir;
+  if (!sessionDir || !fs.existsSync(sessionDir)) return [];
+
+  const events = parseEvents(sessionDir);
+  const result = [];
+
+  // Aggregate token usage from shutdown event's modelMetrics
+  const shutdown = events.find(e => e.type === 'session.shutdown');
+  const modelMetrics = shutdown?.data?.modelMetrics || {};
+
+  // Build total token counts from model metrics
+  let totalInput = 0, totalOutput = 0, totalCacheRead = 0;
+  for (const metrics of Object.values(modelMetrics)) {
+    const u = metrics.usage || {};
+    totalInput += u.inputTokens || 0;
+    totalOutput += u.outputTokens || 0;
+    totalCacheRead += u.cacheReadTokens || 0;
+  }
+
+  for (const event of events) {
+    if (event.type === 'user.message') {
+      const content = event.data?.content;
+      if (content) result.push({ role: 'user', content });
+
+    } else if (event.type === 'assistant.message') {
+      const data = event.data || {};
+      const parts = [];
+      const toolCalls = [];
+
+      // Main text content
+      if (data.content) parts.push(data.content);
+
+      // Tool requests
+      if (data.toolRequests && Array.isArray(data.toolRequests)) {
+        for (const tr of data.toolRequests) {
+          const tcName = tr.name || tr.toolName || 'unknown';
+          const args = tr.args || tr.arguments || tr.input || {};
+          const parsedArgs = typeof args === 'string' ? safeParse(args) : args;
+          const argKeys = typeof parsedArgs === 'object' ? Object.keys(parsedArgs).join(', ') : '';
+          parts.push(`[tool-call: ${tcName}(${argKeys})]`);
+          toolCalls.push({ name: tcName, args: parsedArgs });
+        }
+      }
+
+      if (parts.length > 0) {
+        result.push({
+          role: 'assistant',
+          content: parts.join('\n'),
+          _model: shutdown?.data?.currentModel || chat._model,
+          _outputTokens: data.outputTokens,
+          _toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+      }
+    }
+  }
+
+  // Attach aggregate token info to the first assistant message if available
+  if (result.length > 0 && totalInput > 0) {
+    const firstAssistant = result.find(m => m.role === 'assistant');
+    if (firstAssistant) {
+      firstAssistant._inputTokens = totalInput;
+      if (!firstAssistant._outputTokens) firstAssistant._outputTokens = totalOutput;
+      if (totalCacheRead) firstAssistant._cacheRead = totalCacheRead;
+    }
+  }
+
+  return result;
+}
+
+function safeParse(str) {
+  try { return JSON.parse(str); } catch { return {}; }
+}
+
+// ============================================================
+// Usage / quota data from GitHub Copilot internal API
+// ============================================================
+
+function getCopilotToken() {
+  // GitHub Copilot stores its OAuth token in ~/.config/github-copilot/apps.json
+  const appsPath = path.join(os.homedir(), '.config', 'github-copilot', 'apps.json');
+  try {
+    if (!fs.existsSync(appsPath)) return null;
+    const data = JSON.parse(fs.readFileSync(appsPath, 'utf-8'));
+    for (const entry of Object.values(data)) {
+      if (entry.oauth_token) return { token: entry.oauth_token, user: entry.user || null };
+    }
+  } catch {}
+  return null;
+}
+
+function fetchCopilotStatus(token) {
+  return new Promise((resolve) => {
+    const https = require('https');
+    const req = https.get('https://api.github.com/copilot_internal/v2/token', {
+      headers: {
+        'Authorization': `token ${token}`,
+        'Accept': 'application/json',
+        'User-Agent': 'agentlytics/1.0',
+      },
+      timeout: 10000,
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+async function getUsage() {
+  const { isSubscriptionAccessAllowed } = require('./base');
+  if (!isSubscriptionAccessAllowed()) return null;
+  const creds = getCopilotToken();
+  if (!creds) return null;
+
+  const status = await fetchCopilotStatus(creds.token);
+  if (!status || status.message) return null;
+
+  return {
+    source: 'copilot-cli',
+    plan: {
+      name: status.sku || null,
+      individual: status.individual || false,
+    },
+    features: {
+      chat: status.chat_enabled || false,
+      codeReview: status.code_review_enabled || false,
+      agentMode: status.agent_mode_auto_approval || false,
+    },
+    limits: {
+      quotas: status.limited_user_quotas || null,
+      resetDate: status.limited_user_reset_date || null,
+    },
+    user: {
+      login: creds.user || null,
+    },
+  };
+}
+
+const labels = { 'copilot-cli': 'GitHub Copilot' };
+
+function getArtifacts(folder) {
+  const { scanArtifacts } = require('./base');
+  return scanArtifacts(folder, {
+    editor: 'copilot-cli',
+    label: 'GitHub Copilot',
+    files: ['.github/copilot-instructions.md'],
+    dirs: [],
+  });
+}
+
+function getMCPServers() {
+  // GitHub Copilot shares MCP config with VS Code (handled by vscode.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };

package/editors/cursor-agent.js

@@ -0,0 +1,202 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const CURSOR_PROJECTS_DIR = path.join(os.homedir(), '.cursor', 'projects');
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'cursor-agent';
+
+/**
+ * Decode project directory name back to folder path.
+ * e.g. "Users-fka-Code-Wapple" → "/Users/fka/Code/Wapple"
+ */
+function decodeProjectDir(dirName) {
+  // The encoding replaces "/" with "-". We reconstruct by prepending "/"
+  // and replacing "-" back to "/". Handle ambiguity by checking if path exists.
+  const candidate = '/' + dirName.replace(/-/g, '/');
+  if (fs.existsSync(candidate)) return candidate;
+  // Fallback: try common patterns (the first segment is usually "Users")
+  const parts = dirName.split('-');
+  for (let i = 2; i < parts.length; i++) {
+    const prefix = '/' + parts.slice(0, i).join('/');
+    const suffix = parts.slice(i).join('-');
+    const full = path.join(prefix, suffix);
+    if (fs.existsSync(full)) return full;
+  }
+  return candidate;
+}
+
+/**
+ * Find all agent transcript JSONL files across all projects.
+ * Two patterns:
+ *   - <project>/agent-transcripts/<id>.jsonl (flat)
+ *   - <project>/agent-transcripts/<id>/<id>.jsonl (nested)
+ */
+function findTranscripts() {
+  const results = [];
+  if (!fs.existsSync(CURSOR_PROJECTS_DIR)) return results;
+
+  let projectDirs;
+  try { projectDirs = fs.readdirSync(CURSOR_PROJECTS_DIR); } catch { return results; }
+
+  for (const projDir of projectDirs) {
+    const transcriptsDir = path.join(CURSOR_PROJECTS_DIR, projDir, 'agent-transcripts');
+    if (!fs.existsSync(transcriptsDir)) continue;
+
+    let entries;
+    try { entries = fs.readdirSync(transcriptsDir); } catch { continue; }
+
+    const folder = decodeProjectDir(projDir);
+
+    for (const entry of entries) {
+      const entryPath = path.join(transcriptsDir, entry);
+
+      // Flat pattern: <id>.jsonl
+      if (entry.endsWith('.jsonl')) {
+        const sessionId = entry.replace('.jsonl', '');
+        results.push({ sessionId, jsonlPath: entryPath, folder });
+        continue;
+      }
+
+      // Nested pattern: <id>/<id>.jsonl
+      try {
+        if (fs.statSync(entryPath).isDirectory()) {
+          const nestedJsonl = path.join(entryPath, entry + '.jsonl');
+          if (fs.existsSync(nestedJsonl)) {
+            results.push({ sessionId: entry, jsonlPath: nestedJsonl, folder });
+          }
+        }
+      } catch { /* skip */ }
+    }
+  }
+  return results;
+}
+
+/**
+ * Parse a JSONL transcript file into an array of raw message objects.
+ * Each line: {"role":"user"|"assistant", "message":{"content":[{"type":"text","text":"..."}]}}
+ */
+function parseJsonl(jsonlPath) {
+  try {
+    const raw = fs.readFileSync(jsonlPath, 'utf-8');
+    return raw.split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+/**
+ * Extract the first user query text from a parsed transcript (for chat name).
+ */
+function extractFirstUserText(entries) {
+  for (const e of entries) {
+    if (e.role !== 'user') continue;
+    const parts = e.message?.content;
+    if (!Array.isArray(parts)) continue;
+    for (const p of parts) {
+      if (p.type === 'text' && p.text) {
+        // Strip <user_query> wrapper if present
+        let text = p.text.replace(/<\/?user_query>/g, '').trim();
+        // Strip <attached_files> blocks
+        text = text.replace(/<attached_files>[\s\S]*?<\/attached_files>/g, '').trim();
+        if (text) return text.substring(0, 120);
+      }
+    }
+  }
+  return null;
+}
+
+function getChats() {
+  const chats = [];
+  const transcripts = findTranscripts();
+
+  for (const { sessionId, jsonlPath, folder } of transcripts) {
+    try {
+      const stat = fs.statSync(jsonlPath);
+      const entries = parseJsonl(jsonlPath);
+      if (entries.length === 0) continue;
+
+      // Count user/assistant messages
+      const userCount = entries.filter(e => e.role === 'user').length;
+      const assistantCount = entries.filter(e => e.role === 'assistant').length;
+      const bubbleCount = userCount + assistantCount;
+      if (bubbleCount === 0) continue;
+
+      chats.push({
+        source: 'cursor-agent',
+        composerId: sessionId,
+        name: extractFirstUserText(entries),
+        createdAt: stat.birthtimeMs || stat.mtimeMs,
+        lastUpdatedAt: stat.mtimeMs,
+        mode: 'agent',
+        folder,
+        bubbleCount,
+        _jsonlPath: jsonlPath,
+      });
+    } catch { /* skip */ }
+  }
+
+  return chats;
+}
+
+function getMessages(chat) {
+  const jsonlPath = chat._jsonlPath;
+  if (!jsonlPath || !fs.existsSync(jsonlPath)) return [];
+
+  const entries = parseJsonl(jsonlPath);
+  const result = [];
+
+  for (const entry of entries) {
+    const parts = entry.message?.content;
+    if (!Array.isArray(parts)) continue;
+
+    const textParts = [];
+    for (const p of parts) {
+      if (p.type === 'text' && p.text) {
+        let text = p.text;
+        // Clean up user_query wrappers
+        text = text.replace(/<\/?user_query>/g, '').trim();
+        // Clean attached_files blocks but note file references
+        const fileRefs = [];
+        text = text.replace(/<attached_files>([\s\S]*?)<\/attached_files>/g, (_, inner) => {
+          const paths = inner.match(/path="([^"]+)"/g);
+          if (paths) {
+            for (const pm of paths) {
+              const fp = pm.match(/path="([^"]+)"/);
+              if (fp) fileRefs.push(fp[1]);
+            }
+          }
+          return '';
+        }).trim();
+        // Clean image_files blocks
+        text = text.replace(/<image_files>[\s\S]*?<\/image_files>/g, '[image]').trim();
+        if (text) textParts.push(text);
+        if (fileRefs.length > 0) {
+          textParts.push(fileRefs.map(f => `[file: ${f}]`).join('\n'));
+        }
+      }
+    }
+
+    if (textParts.length > 0) {
+      result.push({
+        role: entry.role === 'user' ? 'user' : 'assistant',
+        content: textParts.join('\n'),
+      });
+    }
+  }
+
+  return result;
+}
+
+const labels = { 'cursor-agent': 'Cursor Agent' };
+
+function getMCPServers() {
+  // Cursor Agent shares MCP config with Cursor (handled by cursor.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };