monty-data 1.0.0

package/bin/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const claudeCode = require('../lib/claude-code');
+const codex = require('../lib/codex');
+const cursor = require('../lib/cursor');
+const { upload } = require('../lib/upload');
+const { detect } = require('../lib/user');
+
+async function main() {
+  console.log('\n🔍 monty-data: Extracting AI coding tool data\n');
+
+  const ccData = claudeCode.extract();
+  const codexData = codex.extract();
+  const cursorData = cursor.extract();
+
+  const combined = {
+    sessions: [...ccData.sessions, ...codexData.sessions, ...cursorData.sessions],
+    messages: [...ccData.messages, ...codexData.messages, ...cursorData.messages],
+    toolCalls: [...ccData.toolCalls, ...codexData.toolCalls, ...cursorData.toolCalls]
+  };
+
+  const userTotal = combined.messages.filter(m => m.role === 'user').length;
+  const assistantTotal = combined.messages.filter(m => m.role === 'assistant').length;
+
+  console.log(`\n  TOTALS: ${userTotal} prompts, ${assistantTotal} responses, ${combined.toolCalls.length} tool calls`);
+
+  console.log('\n👤 Detecting user...');
+  const user = detect();
+  console.log(`  ${user.full_name} (${user.git_email}) — ${user.os_username}@${user.hostname}`);
+  if (user.github_username) console.log(`  GitHub: ${user.github_username}`);
+  if (user.openai_email) console.log(`  OpenAI: ${user.openai_email}`);
+
+  console.log('\n📤 Uploading to Supabase...\n');
+
+  const result = await upload(combined, user);
+
+  console.log('\n✅ Done!');
+  console.log(`  Sessions:   ${result.sessionsUploaded}`);
+  console.log(`  Messages:   ${result.messagesUploaded}`);
+  console.log(`  Tool calls: ${result.toolCallsUploaded}\n`);
+}
+
+main().catch(e => {
+  console.error('Error:', e.message);
+  process.exit(1);
+});

package/lib/claude-code.js

@@ -0,0 +1,215 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+const HISTORY_FILE = path.join(CLAUDE_DIR, 'history.jsonl');
+
+const SYSTEM_TAG_RE = /^<(task-notification|local-command-caveat|bash-input|bash-stdout|local-command-stdout|command-name|system-reminder|user-prompt-submit-hook)/;
+
+function parseTimestamp(ts) {
+  if (!ts) return null;
+  if (typeof ts === 'string') {
+    return new Date(ts.replace('Z', '+00:00')).toISOString();
+  }
+  return new Date(ts).toISOString();
+}
+
+function extractSessions() {
+  const sessions = [];
+  const sessionFiles = [];
+
+  if (!fs.existsSync(PROJECTS_DIR)) return { sessions, messages: [], toolCalls: [] };
+
+  for (const projDir of fs.readdirSync(PROJECTS_DIR)) {
+    const projPath = path.join(PROJECTS_DIR, projDir);
+    if (!fs.statSync(projPath).isDirectory()) continue;
+
+    for (const file of fs.readdirSync(projPath)) {
+      if (!file.endsWith('.jsonl') || !file.match(/^[0-9a-f]{8}-/)) continue;
+      sessionFiles.push({
+        path: path.join(projPath, file),
+        sessionId: file.replace('.jsonl', ''),
+        project: projDir
+      });
+    }
+  }
+
+  return sessionFiles;
+}
+
+function processSessionFile(filePath, sessionId, project) {
+  const messages = [];
+  const toolCalls = [];
+  let sessionCreatedAt = null;
+  let sessionModel = null;
+  let sessionCwd = null;
+  let sessionTitle = null;
+
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+
+    const ts = parseTimestamp(d.timestamp);
+
+    if (d.type === 'user') {
+      if (!sessionCreatedAt) sessionCreatedAt = ts;
+      if (!sessionCwd && d.cwd) sessionCwd = d.cwd;
+
+      const msg = d.message || {};
+      const content = msg.content || '';
+      let text = '';
+
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .filter(c => typeof c === 'object' && c.type === 'text')
+          .map(c => c.text || '')
+          .join('\n');
+      }
+
+      if (text.trim() && !SYSTEM_TAG_RE.test(text.trim())) {
+        messages.push({
+          session_id: sessionId,
+          source: 'claude-code',
+          role: 'user',
+          content: text.trim(),
+          timestamp: ts,
+          model: null
+        });
+      }
+    } else if (d.type === 'assistant') {
+      const msg = d.message || {};
+      const content = msg.content || '';
+      let text = '';
+      const tools = [];
+
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (!c || typeof c !== 'object') continue;
+          if (c.type === 'text' && c.text) {
+            text += (text ? '\n' : '') + c.text;
+          } else if (c.type === 'tool_use') {
+            tools.push({
+              session_id: sessionId,
+              source: 'claude-code',
+              tool_name: c.name || null,
+              tool_input: c.input ? JSON.stringify(c.input).substring(0, 50000) : null,
+              tool_output: null,
+              timestamp: ts
+            });
+          }
+        }
+      }
+
+      if (!sessionModel && msg.model) sessionModel = msg.model;
+
+      if (text.trim()) {
+        messages.push({
+          session_id: sessionId,
+          source: 'claude-code',
+          role: 'assistant',
+          content: text.trim(),
+          timestamp: ts,
+          model: msg.model || null
+        });
+      }
+
+      toolCalls.push(...tools);
+    } else if (d.type === 'ai-title' && d.title) {
+      sessionTitle = d.title;
+    }
+  }
+
+  const session = {
+    id: sessionId,
+    source: 'claude-code',
+    project: project.replace(/-/g, '/').replace(/^\//, ''),
+    created_at: sessionCreatedAt,
+    title: sessionTitle,
+    model: sessionModel,
+    cwd: sessionCwd
+  };
+
+  return { session, messages, toolCalls };
+}
+
+function extractHistoryPrompts(existingSessionIds) {
+  const messages = [];
+  const sessionMeta = [];
+
+  if (!fs.existsSync(HISTORY_FILE)) return { messages, sessionMeta };
+
+  const lines = fs.readFileSync(HISTORY_FILE, 'utf-8').split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+
+    if (!d.display || !d.timestamp || !d.sessionId) continue;
+    if (existingSessionIds.has(d.sessionId)) continue;
+
+    if (!existingSessionIds.has(d.sessionId)) {
+      sessionMeta.push({
+        id: d.sessionId,
+        source: 'claude-code',
+        project: d.project ? d.project.replace(os.homedir(), '~') : null,
+        created_at: new Date(d.timestamp).toISOString(),
+        title: null,
+        model: null,
+        cwd: d.project || null
+      });
+      existingSessionIds.add(d.sessionId);
+    }
+
+    messages.push({
+      session_id: d.sessionId,
+      source: 'claude-code',
+      role: 'user',
+      content: d.display,
+      timestamp: new Date(d.timestamp).toISOString(),
+      model: null
+    });
+  }
+
+  return { messages, sessionMeta };
+}
+
+function extract() {
+  console.log('  Scanning Claude Code data...');
+  const sessionFiles = extractSessions();
+  const allSessions = [];
+  const allMessages = [];
+  const allToolCalls = [];
+  const processedSessionIds = new Set();
+
+  for (const { path: fp, sessionId, project } of sessionFiles) {
+    try {
+      const { session, messages, toolCalls } = processSessionFile(fp, sessionId, project);
+      allSessions.push(session);
+      allMessages.push(...messages);
+      allToolCalls.push(...toolCalls);
+      processedSessionIds.add(sessionId);
+    } catch (e) {
+      // skip corrupt files
+    }
+  }
+
+  const { messages: historyMsgs, sessionMeta } = extractHistoryPrompts(processedSessionIds);
+  allSessions.push(...sessionMeta);
+  allMessages.push(...historyMsgs);
+
+  const userCount = allMessages.filter(m => m.role === 'user').length;
+  const assistantCount = allMessages.filter(m => m.role === 'assistant').length;
+  console.log(`  Found ${allSessions.length} sessions, ${userCount} prompts, ${assistantCount} responses, ${allToolCalls.length} tool calls`);
+
+  return { sessions: allSessions, messages: allMessages, toolCalls: allToolCalls };
+}
+
+module.exports = { extract };

package/lib/codex.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const Database = require('better-sqlite3');
+
+const CODEX_DIR = path.join(os.homedir(), '.codex');
+const SESSIONS_DIR = path.join(CODEX_DIR, 'sessions');
+const HISTORY_FILE = path.join(CODEX_DIR, 'history.jsonl');
+const STATE_DB = path.join(CODEX_DIR, 'state_5.sqlite');
+
+const AUTOMATED_PREFIXES = [
+  'You will see multiple computer screen snapshots attached in the order provided.',
+  'You are given timestamped screen descriptions from a video',
+  "You are synthesizing a user's activity log into timeline cards. Each card represents one main thing they did.",
+];
+
+function findSessionFiles() {
+  const files = [];
+  if (!fs.existsSync(SESSIONS_DIR)) return files;
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith('.jsonl')) files.push(full);
+    }
+  }
+  walk(SESSIONS_DIR);
+  return files;
+}
+
+function getThreadMeta() {
+  const meta = {};
+  if (!fs.existsSync(STATE_DB)) return meta;
+
+  try {
+    const db = new Database(STATE_DB, { readonly: true });
+    const rows = db.prepare('SELECT id, title, cwd, model, created_at FROM threads').all();
+    for (const row of rows) {
+      meta[row.id] = {
+        title: row.title || null,
+        cwd: row.cwd || null,
+        model: row.model || null,
+        created_at: row.created_at ? new Date(row.created_at * 1000).toISOString() : null
+      };
+    }
+    db.close();
+  } catch (e) {
+    // sqlite might be locked
+  }
+  return meta;
+}
+
+function processSessionFile(filePath, threadMeta) {
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+  const messages = [];
+  const toolCalls = [];
+  let sessionId = null;
+  let sessionCreatedAt = null;
+  let sessionCwd = null;
+  let sessionModel = null;
+  let sessionTitle = null;
+
+  for (const line of lines) {
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+
+    const ts = d.timestamp ? new Date(d.timestamp).toISOString() : null;
+    const payload = d.payload || {};
+
+    if (d.type === 'session_meta') {
+      sessionId = payload.thread_id || payload.session_id || null;
+      sessionCwd = payload.cwd || null;
+      sessionModel = payload.model || null;
+    } else if (d.type === 'event_msg' && payload.type === 'user_message') {
+      if (!sessionCreatedAt) sessionCreatedAt = ts;
+      const text = payload.message || '';
+      if (text.trim()) {
+        messages.push({
+          session_id: null,
+          source: 'codex',
+          role: 'user',
+          content: text.trim(),
+          timestamp: ts,
+          model: null
+        });
+      }
+    } else if (d.type === 'response_item') {
+      if (payload.type === 'message' && payload.role === 'assistant') {
+        const content = payload.content || [];
+        const texts = [];
+        if (Array.isArray(content)) {
+          for (const c of content) {
+            if (c && c.type === 'output_text' && c.text) texts.push(c.text);
+          }
+        }
+        const text = texts.join('\n').trim();
+        if (text) {
+          messages.push({
+            session_id: null,
+            source: 'codex',
+            role: 'assistant',
+            content: text,
+            timestamp: ts,
+            model: sessionModel
+          });
+        }
+      } else if (payload.type === 'function_call') {
+        toolCalls.push({
+          session_id: null,
+          source: 'codex',
+          tool_name: payload.name || null,
+          tool_input: payload.arguments ? payload.arguments.substring(0, 50000) : null,
+          tool_output: null,
+          timestamp: ts
+        });
+      } else if (payload.type === 'function_call_output') {
+        const lastTool = toolCalls[toolCalls.length - 1];
+        if (lastTool && !lastTool.tool_output) {
+          const output = payload.output || '';
+          lastTool.tool_output = output.substring(0, 50000);
+        }
+      }
+    }
+  }
+
+  if (!sessionId) {
+    const match = filePath.match(/([0-9a-f]{8}-[0-9a-f-]+)\.jsonl$/);
+    sessionId = match ? match[1] : path.basename(filePath, '.jsonl');
+  }
+
+  const meta = threadMeta[sessionId] || {};
+  const project = sessionCwd || meta.cwd || null;
+
+  for (const m of messages) m.session_id = sessionId;
+  for (const t of toolCalls) t.session_id = sessionId;
+
+  const session = {
+    id: sessionId,
+    source: 'codex',
+    project: project ? project.replace(os.homedir(), '~') : null,
+    created_at: meta.created_at || sessionCreatedAt,
+    title: meta.title || sessionTitle,
+    model: meta.model || sessionModel,
+    cwd: project
+  };
+
+  return { session, messages, toolCalls };
+}
+
+function extract() {
+  console.log('  Scanning Codex data...');
+  const sessionFiles = findSessionFiles();
+  const threadMeta = getThreadMeta();
+  const allSessions = [];
+  const allMessages = [];
+  const allToolCalls = [];
+
+  let skippedAuto = 0;
+  for (const fp of sessionFiles) {
+    try {
+      const { session, messages, toolCalls } = processSessionFile(fp, threadMeta);
+      const firstUserMsg = messages.find(m => m.role === 'user');
+      if (firstUserMsg && AUTOMATED_PREFIXES.some(p => firstUserMsg.content.startsWith(p))) {
+        skippedAuto++;
+        continue;
+      }
+      allSessions.push(session);
+      allMessages.push(...messages);
+      allToolCalls.push(...toolCalls);
+    } catch (e) {
+      // skip corrupt files
+    }
+  }
+  if (skippedAuto > 0) console.log(`  Skipped ${skippedAuto} automated screen analysis sessions`);
+
+  const userCount = allMessages.filter(m => m.role === 'user').length;
+  const assistantCount = allMessages.filter(m => m.role === 'assistant').length;
+  console.log(`  Found ${allSessions.length} sessions, ${userCount} prompts, ${assistantCount} responses, ${allToolCalls.length} tool calls`);
+
+  return { sessions: allSessions, messages: allMessages, toolCalls: allToolCalls };
+}
+
+module.exports = { extract };

package/lib/cursor.js

@@ -0,0 +1,286 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const Database = require('better-sqlite3');
+
+const CURSOR_DIR = path.join(os.homedir(), '.cursor');
+const CHATS_DIR = path.join(CURSOR_DIR, 'chats');
+const GLOBAL_STATE_DB = path.join(
+  os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'
+);
+
+const CURSOR_META_RE = /^<(open_and_recently_viewed_files|user_info|attached_files|relevant_files|instructions|custom_instructions|repo_map|selection|timestamp|system_notification)/;
+const USER_QUERY_RE = /<user_query>([\s\S]*?)<\/user_query>/;
+const SYSTEM_REMINDER_BLOCK_RE = /<system_reminder>[\s\S]*?<\/system_reminder>\s*/g;
+
+function extractUserQuery(text) {
+  const match = text.match(USER_QUERY_RE);
+  if (match) {
+    const q = match[1].replace(SYSTEM_REMINDER_BLOCK_RE, '').trim();
+    return q || null;
+  }
+  let cleaned = text.replace(SYSTEM_REMINDER_BLOCK_RE, '').trim();
+  if (!cleaned) return null;
+  if (CURSOR_META_RE.test(cleaned)) return null;
+  if (cleaned.startsWith('[Previous conversation summary]')) return null;
+  return cleaned;
+}
+
+function findChatDbs() {
+  const dbs = [];
+  if (!fs.existsSync(CHATS_DIR)) return dbs;
+
+  for (const workspace of fs.readdirSync(CHATS_DIR)) {
+    const wsPath = path.join(CHATS_DIR, workspace);
+    if (!fs.statSync(wsPath).isDirectory()) continue;
+    for (const chat of fs.readdirSync(wsPath)) {
+      const chatPath = path.join(wsPath, chat);
+      const dbPath = path.join(chatPath, 'store.db');
+      if (fs.existsSync(dbPath)) {
+        dbs.push({ path: dbPath, workspace, chatId: chat });
+      }
+    }
+  }
+  return dbs;
+}
+
+function processChatDb(dbPath, workspace, chatId) {
+  const messages = [];
+  const toolCalls = [];
+  let sessionCreatedAt = null;
+  let sessionTitle = null;
+  let sessionModel = null;
+
+  try {
+    const db = new Database(dbPath, { readonly: true });
+
+    // Get meta
+    const metaRows = db.prepare('SELECT key, value FROM meta').all();
+    for (const row of metaRows) {
+      try {
+        const decoded = Buffer.from(row.value, 'hex').toString('utf-8');
+        const meta = JSON.parse(decoded);
+        sessionCreatedAt = meta.createdAt ? new Date(meta.createdAt).toISOString() : null;
+        sessionTitle = meta.name || null;
+        sessionModel = meta.model || null;
+      } catch {}
+    }
+
+    // Get blobs
+    const blobs = db.prepare('SELECT id, data FROM blobs').all();
+    for (const blob of blobs) {
+      let parsed;
+      try {
+        const text = typeof blob.data === 'string' ? blob.data : blob.data.toString('utf-8');
+        parsed = JSON.parse(text);
+      } catch { continue; }
+
+      const role = parsed.role;
+      if (!role) continue;
+
+      const content = parsed.content || '';
+      let text = '';
+
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (!c || typeof c !== 'object') continue;
+          if ((c.type === 'text' || c.type === 'output_text') && c.text) {
+            text += (text ? '\n' : '') + c.text;
+          }
+        }
+      }
+
+      if (role === 'user' && text.trim()) {
+        const userText = extractUserQuery(text);
+        if (userText) {
+          messages.push({
+            session_id: chatId,
+            source: 'cursor',
+            role: 'user',
+            content: userText.substring(0, 100000),
+            timestamp: sessionCreatedAt,
+            model: null
+          });
+        }
+      } else if (role === 'assistant' && text.trim()) {
+        messages.push({
+          session_id: chatId,
+          source: 'cursor',
+          role: 'assistant',
+          content: text.trim().substring(0, 100000),
+          timestamp: sessionCreatedAt,
+          model: sessionModel
+        });
+      } else if (role === 'tool') {
+        const toolContent = typeof content === 'string' ? content : JSON.stringify(content);
+        toolCalls.push({
+          session_id: chatId,
+          source: 'cursor',
+          tool_name: parsed.name || null,
+          tool_input: null,
+          tool_output: toolContent.substring(0, 50000),
+          timestamp: sessionCreatedAt
+        });
+      }
+    }
+
+    db.close();
+  } catch (e) {
+    // skip corrupt or locked dbs
+  }
+
+  const session = {
+    id: chatId,
+    source: 'cursor',
+    project: workspace,
+    created_at: sessionCreatedAt,
+    title: sessionTitle,
+    model: sessionModel,
+    cwd: null
+  };
+
+  return { session, messages, toolCalls };
+}
+
+function extractGlobalStateMessages() {
+  const messages = [];
+  const toolCalls = [];
+  const sessions = [];
+  const seenSessions = new Set();
+
+  if (!fs.existsSync(GLOBAL_STATE_DB)) return { sessions, messages, toolCalls };
+
+  try {
+    const db = new Database(GLOBAL_STATE_DB, { readonly: true });
+
+    // Check if cursorDiskKV table exists
+    const tableCheck = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'"
+    ).get();
+    if (!tableCheck) { db.close(); return { sessions, messages, toolCalls }; }
+
+    const rows = db.prepare(
+      "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'agentKv:blob:%'"
+    ).all();
+
+    let globalSessionId = 'cursor-global-state';
+    let userCount = 0;
+    let assistantCount = 0;
+
+    for (const row of rows) {
+      let parsed;
+      try {
+        const data = typeof row.value === 'string' ? row.value : row.value.toString('utf-8');
+        parsed = JSON.parse(data);
+      } catch { continue; }
+
+      const role = parsed.role;
+      if (!role) continue;
+
+      const content = parsed.content || '';
+      let text = '';
+
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (!c || typeof c !== 'object') continue;
+          if ((c.type === 'text' || c.type === 'output_text') && c.text) {
+            text += (text ? '\n' : '') + c.text;
+          }
+        }
+      }
+
+      if (role === 'user' && text.trim()) {
+        const userText = extractUserQuery(text);
+        if (userText) {
+          messages.push({
+            session_id: globalSessionId,
+            source: 'cursor',
+            role: 'user',
+            content: userText.substring(0, 100000),
+            timestamp: null,
+            model: null
+          });
+          userCount++;
+        }
+      } else if (role === 'assistant' && text.trim()) {
+        messages.push({
+          session_id: globalSessionId,
+          source: 'cursor',
+          role: 'assistant',
+          content: text.trim().substring(0, 100000),
+          timestamp: null,
+          model: null
+        });
+        assistantCount++;
+      } else if (role === 'tool') {
+        const toolContent = typeof content === 'string' ? content : JSON.stringify(content);
+        toolCalls.push({
+          session_id: globalSessionId,
+          source: 'cursor',
+          tool_name: parsed.name || null,
+          tool_input: null,
+          tool_output: toolContent.substring(0, 50000),
+          timestamp: null
+        });
+      }
+    }
+
+    if (userCount > 0 || assistantCount > 0) {
+      sessions.push({
+        id: globalSessionId,
+        source: 'cursor',
+        project: 'globalStorage',
+        created_at: null,
+        title: 'Cursor Global State Messages',
+        model: null,
+        cwd: null
+      });
+    }
+
+    db.close();
+  } catch (e) {
+    // skip if locked or corrupt
+  }
+
+  return { sessions, messages, toolCalls };
+}
+
+function extract() {
+  console.log('  Scanning Cursor data...');
+  const chatDbs = findChatDbs();
+  const allSessions = [];
+  const allMessages = [];
+  const allToolCalls = [];
+
+  // Process chat store.db files
+  for (const { path: dbPath, workspace, chatId } of chatDbs) {
+    try {
+      const { session, messages, toolCalls } = processChatDb(dbPath, workspace, chatId);
+      if (messages.length > 0) {
+        allSessions.push(session);
+        allMessages.push(...messages);
+        allToolCalls.push(...toolCalls);
+      }
+    } catch (e) {
+      // skip
+    }
+  }
+
+  // Process globalStorage agentKv blobs
+  const global = extractGlobalStateMessages();
+  allSessions.push(...global.sessions);
+  allMessages.push(...global.messages);
+  allToolCalls.push(...global.toolCalls);
+
+  const userCount = allMessages.filter(m => m.role === 'user').length;
+  const assistantCount = allMessages.filter(m => m.role === 'assistant').length;
+  console.log(`  Found ${allSessions.length} sessions, ${userCount} prompts, ${assistantCount} responses, ${allToolCalls.length} tool calls`);
+
+  return { sessions: allSessions, messages: allMessages, toolCalls: allToolCalls };
+}
+
+module.exports = { extract };

package/lib/upload.js

@@ -0,0 +1,117 @@
+const { createClient } = require('@supabase/supabase-js');
+
+const SUPABASE_URL = 'https://jrnptnvcpkympgxqhjnu.supabase.co';
+const SUPABASE_SERVICE_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpybnB0bnZjcGt5bXBneHFoam51Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2MjgzMjYxMiwiZXhwIjoyMDc4NDA4NjEyfQ.IL4jKwOvnVGcHjlOxDFFvrxNy9OLrebh67VhY_YMgOc';
+
+const BATCH_SIZE = 500;
+
+// PostgreSQL cannot store null bytes in text columns
+const NULL_BYTE_RE = /\0/g;
+
+function sanitize(rows) {
+  return rows.map(row => {
+    const clean = { ...row };
+    for (const key of Object.keys(clean)) {
+      if (typeof clean[key] === 'string') {
+        clean[key] = clean[key].replace(NULL_BYTE_RE, '');
+      }
+    }
+    return clean;
+  });
+}
+
+function getClient() {
+  return createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY);
+}
+
+async function checkTablesExist(supabase) {
+  const { error } = await supabase.from('sessions').select('id').limit(1);
+  return !error || error.code !== 'PGRST205';
+}
+
+async function clearExistingData(supabase) {
+  console.log('  Clearing existing data...');
+  await supabase.from('tool_calls').delete().neq('id', 0);
+  await supabase.from('messages').delete().neq('id', 0);
+  await supabase.from('sessions').delete().neq('id', '');
+}
+
+async function upsertUser(supabase, user) {
+  const { error } = await supabase.from('users').upsert(user, { onConflict: 'id' });
+  if (error) {
+    console.error('  Error upserting user:', error.message);
+    return null;
+  }
+  return user.id;
+}
+
+async function uploadBatch(supabase, table, rows) {
+  if (rows.length === 0) return 0;
+
+  const clean = sanitize(rows);
+  let uploaded = 0;
+  for (let i = 0; i < clean.length; i += BATCH_SIZE) {
+    const batch = clean.slice(i, i + BATCH_SIZE);
+    const { error } = await supabase.from(table).insert(batch);
+    if (error) {
+      console.error(`  Error uploading to ${table} (batch ${Math.floor(i / BATCH_SIZE) + 1}): ${error.message}`);
+      for (const row of batch) {
+        const { error: rowError } = await supabase.from(table).insert(row);
+        if (!rowError) uploaded++;
+      }
+    } else {
+      uploaded += batch.length;
+    }
+
+    const pct = Math.round(((i + batch.length) / clean.length) * 100);
+    process.stdout.write(`\r  Uploading ${table}: ${pct}% (${uploaded}/${clean.length})`);
+  }
+  console.log();
+  return uploaded;
+}
+
+async function upload(data, user) {
+  const supabase = getClient();
+
+  const tablesExist = await checkTablesExist(supabase);
+  if (!tablesExist) {
+    console.error('\n  ERROR: Tables do not exist in Supabase.');
+    console.error('  Please run setup.sql in the Supabase SQL Editor first:');
+    console.error('  https://supabase.com/dashboard/project/jrnptnvcpkympgxqhjnu/sql\n');
+    process.exit(1);
+  }
+
+  await clearExistingData(supabase);
+
+  let userId = null;
+  if (user) {
+    userId = await upsertUser(supabase, user);
+    if (userId) console.log(`  User: ${user.full_name || user.os_username} (${user.git_email})`);
+  }
+
+  const sessionMap = new Map();
+  for (const s of data.sessions) {
+    if (!sessionMap.has(s.id)) sessionMap.set(s.id, s);
+  }
+  const sessions = Array.from(sessionMap.values());
+  if (userId) {
+    for (const s of sessions) s.user_id = userId;
+  }
+
+  console.log(`\n  Uploading ${sessions.length} sessions...`);
+  const sessionsUploaded = await uploadBatch(supabase, 'sessions', sessions);
+
+  if (userId) {
+    for (const m of data.messages) m.user_id = userId;
+  }
+
+  console.log(`  Uploading ${data.messages.length} messages...`);
+  const messagesUploaded = await uploadBatch(supabase, 'messages', data.messages);
+
+  console.log(`  Uploading ${data.toolCalls.length} tool calls...`);
+  const toolCallsUploaded = await uploadBatch(supabase, 'tool_calls', data.toolCalls);
+
+  return { sessionsUploaded, messagesUploaded, toolCallsUploaded };
+}
+
+module.exports = { upload, getClient, checkTablesExist };

package/lib/user.js

@@ -0,0 +1,51 @@
+const os = require('os');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function run(cmd) {
+  try { return execSync(cmd, { encoding: 'utf-8', timeout: 5000 }).trim(); } catch { return null; }
+}
+
+function detect() {
+  const osUsername = os.userInfo().username;
+  const hostname = os.hostname();
+  const fullName = run('git config --global user.name');
+  const gitEmail = run('git config --global user.email');
+
+  let githubUsername = null;
+  const ghStatus = run('gh auth status 2>&1');
+  if (ghStatus) {
+    const match = ghStatus.match(/Logged in to github\.com account (\S+)/);
+    if (match) githubUsername = match[1];
+  }
+
+  let openaiEmail = null;
+  const codexAuthPath = path.join(os.homedir(), '.codex', 'auth.json');
+  try {
+    const auth = JSON.parse(fs.readFileSync(codexAuthPath, 'utf-8'));
+    const idToken = auth.tokens?.id_token;
+    if (idToken) {
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      openaiEmail = payload.email || null;
+    }
+  } catch {}
+
+  const id = crypto.createHash('sha256')
+    .update(`${osUsername}@${hostname}`)
+    .digest('hex')
+    .substring(0, 16);
+
+  return {
+    id,
+    os_username: osUsername,
+    hostname,
+    full_name: fullName,
+    git_email: gitEmail,
+    github_username: githubUsername,
+    openai_email: openaiEmail,
+  };
+}
+
+module.exports = { detect };

package/migrate-add-users.sql

@@ -0,0 +1,18 @@
+-- Run this in the Supabase SQL Editor to add the users table
+-- https://supabase.com/dashboard/project/jrnptnvcpkympgxqhjnu/sql
+
+CREATE TABLE IF NOT EXISTS users (
+  id TEXT PRIMARY KEY,
+  os_username TEXT,
+  hostname TEXT,
+  full_name TEXT,
+  git_email TEXT,
+  github_username TEXT,
+  openai_email TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+ALTER TABLE sessions ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES users(id) ON DELETE SET NULL;
+ALTER TABLE messages ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES users(id) ON DELETE SET NULL;
+CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_messages_user ON messages(user_id);

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "monty-data",
+  "version": "1.0.0",
+  "description": "Extract and upload Claude Code, Codex, and Cursor conversation data to Supabase",
+  "main": "index.js",
+  "bin": {
+    "monty-data": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node bin/cli.js",
+    "upload": "node bin/cli.js"
+  },
+  "keywords": ["claude", "codex", "cursor", "ai", "data"],
+  "author": "Ethan Goodhart",
+  "license": "MIT",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.108.2",
+    "better-sqlite3": "^12.11.1"
+  }
+}

package/setup.sql

@@ -0,0 +1,68 @@
+-- Run this once in the Supabase SQL Editor (https://supabase.com/dashboard/project/jrnptnvcpkympgxqhjnu/sql)
+
+DROP TABLE IF EXISTS tool_calls CASCADE;
+DROP TABLE IF EXISTS messages CASCADE;
+DROP TABLE IF EXISTS sessions CASCADE;
+DROP TABLE IF EXISTS users CASCADE;
+
+CREATE TABLE users (
+  id TEXT PRIMARY KEY,
+  os_username TEXT,
+  hostname TEXT,
+  full_name TEXT,
+  git_email TEXT,
+  github_username TEXT,
+  openai_email TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,
+  user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+  source TEXT NOT NULL,
+  project TEXT,
+  created_at TIMESTAMPTZ,
+  title TEXT,
+  model TEXT,
+  cwd TEXT
+);
+
+CREATE TABLE messages (
+  id BIGSERIAL PRIMARY KEY,
+  session_id TEXT REFERENCES sessions(id) ON DELETE CASCADE,
+  user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+  source TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT,
+  timestamp TIMESTAMPTZ,
+  model TEXT
+);
+
+CREATE TABLE tool_calls (
+  id BIGSERIAL PRIMARY KEY,
+  session_id TEXT REFERENCES sessions(id) ON DELETE CASCADE,
+  source TEXT NOT NULL,
+  tool_name TEXT,
+  tool_input TEXT,
+  tool_output TEXT,
+  timestamp TIMESTAMPTZ
+);
+
+CREATE INDEX idx_messages_session ON messages(session_id);
+CREATE INDEX idx_messages_role ON messages(role);
+CREATE INDEX idx_messages_source ON messages(source);
+CREATE INDEX idx_messages_timestamp ON messages(timestamp);
+CREATE INDEX idx_tool_calls_session ON tool_calls(session_id);
+CREATE INDEX idx_tool_calls_source ON tool_calls(source);
+CREATE INDEX idx_sessions_source ON sessions(source);
+
+-- Helper function so the package can create tables via RPC if needed
+CREATE OR REPLACE FUNCTION setup_monty_tables()
+RETURNS TEXT
+LANGUAGE plpgsql
+SECURITY DEFINER
+AS $$
+BEGIN
+  RETURN 'tables_ready';
+END;
+$$;