agentlytics 0.0.11 → 0.1.0

package/README.md

@@ -48,6 +48,7 @@ For local development, run `npm run dev` from the repo root. That starts both th
 - **Deep Analysis** — Tool frequency, model distribution, token breakdown with drill-down
 - **Compare** — Side-by-side editor comparison with efficiency ratios
 - **Refetch** — One-click cache rebuild with live progress
+- **Relay** — Multi-user context sharing with MCP server for cross-team AI session querying
 
 ## Supported Editors
 
@@ -72,13 +73,89 @@ For local development, run `npm run dev` from the repo root. That starts both th
 
 Codex sessions are read from `${CODEX_HOME:-~/.codex}/sessions/**/*.jsonl`. Reasoning summaries may appear in transcripts when Codex records them in clear text, but encrypted reasoning content is not readable. Codex Desktop and CLI sessions are aggregated into one `codex` editor in analytics.
 
+## Relay
+
+Relay enables multi-user context sharing across a team. One person starts a relay server, others join and share selected project sessions. An MCP server is exposed so AI clients can query across everyone's coding history.
+
+### Start a relay
+
+```bash
+npx agentlytics --relay
+```
+
+Optionally protect with a password:
+
+```bash
+RELAY_PASSWORD=secret npx agentlytics --relay
+```
+
+This starts a relay server on port `4638` and prints the join command and MCP endpoint:
+
+```
+  ⚡ Agentlytics Relay
+
+  Share this command with your team:
+    cd /path/to/project
+    npx agentlytics --join 192.168.1.16:4638
+
+  MCP server endpoint (add to your AI client):
+    http://192.168.1.16:4638/mcp
+```
+
+### Join a relay
+
+```bash
+cd /path/to/your-project
+npx agentlytics --join <host:port>
+```
+
+If the relay is password-protected:
+
+```bash
+RELAY_PASSWORD=secret npx agentlytics --join <host:port>
+```
+
+Username is auto-detected from `git config user.email`. You can override it with `--username <name>`.
+
+You'll be prompted to select which projects to share. The client then syncs session data to the relay every 30 seconds.
+
+### MCP Tools
+
+Connect your AI client to the relay's MCP endpoint (`http://<host>:4638/mcp`) to access these tools:
+
+| Tool | Description |
+|------|-------------|
+| `list_users` | List all connected users and their shared projects |
+| `search_sessions` | Full-text search across all users' chat messages |
+| `get_user_activity` | Get recent sessions for a specific user |
+| `get_session_detail` | Get full conversation messages for a session |
+
+Example query to your AI: *"What did alice do in auth.js?"*
+
+### Relay REST API
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /relay/health` | Health check and user count |
+| `GET /relay/users` | List connected users |
+| `GET /relay/search?q=<query>` | Search messages across all users |
+| `GET /relay/activity/:username` | User's recent sessions |
+| `GET /relay/session/:chatId` | Full session detail |
+| `POST /relay/sync` | Receives data from join clients |
+
+> Relay is designed for trusted local networks. Set `RELAY_PASSWORD` env on both server and clients to enable password protection.
+
 ## How It Works
 
 ```
 Editor files/APIs → editors/*.js → cache.js (SQLite) → server.js (REST) → React SPA
 ```
 
-All data is normalized into a local SQLite cache at `~/.agentlytics/cache.db`. The Express server exposes read-only REST endpoints consumed by the React frontend.
+```
+Relay:  join clients → POST /relay/sync → relay.db (SQLite) → MCP server → AI clients
+```
+
+All data is normalized into a local SQLite cache at `~/.agentlytics/cache.db`. The Express server exposes read-only REST endpoints consumed by the React frontend. Relay data is stored separately in `~/.agentlytics/relay.db`.
 
 ## API
 

package/cache.js

@@ -2,7 +2,7 @@ const Database = require('better-sqlite3');
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
-const { getAllChats, getMessages, findChat: findChatRaw } = require('./editors');
+const { getAllChats, getMessages, findChat: findChatRaw, resetCaches } = require('./editors');
 
 const CACHE_DIR = path.join(os.homedir(), '.agentlytics');
 const CACHE_DB = path.join(CACHE_DIR, 'cache.db');
@@ -190,7 +190,9 @@ function analyzeAndStore(chat) {
   );
 }
 
-function scanAll(onProgress) {
+function scanAll(onProgress, opts = {}) {
+  const force = opts.force || false;
+  if (force || opts.resetCaches) resetCaches();
   const chats = getAllChats();
   const total = chats.length;
   let scanned = 0;
@@ -199,8 +201,8 @@ function scanAll(onProgress) {
 
   // Check which chats need updating
   const existing = {};
-  for (const row of db.prepare('SELECT id, last_updated_at FROM chats').all()) {
-    existing[row.id] = row.last_updated_at;
+  for (const row of db.prepare('SELECT id, last_updated_at, bubble_count FROM chats').all()) {
+    existing[row.id] = { ts: row.last_updated_at, bc: row.bubble_count };
   }
 
   const ins = insertChat();
@@ -224,11 +226,14 @@ function scanAll(onProgress) {
   // Analyze messages for chats that are new or updated
   for (const chat of chats) {
     scanned++;
-    const cachedTs = existing[chat.composerId];
     const chatTs = chat.lastUpdatedAt || chat.createdAt || 0;
 
-    // Skip if already cached and not updated
-    if (cachedTs && cachedTs >= chatTs) {
+    // Skip if already cached and not updated (unless force rescan)
+    const cached = existing[chat.composerId];
+    const cachedTs = cached ? cached.ts : null;
+    const cachedBc = cached ? cached.bc : null;
+    const chatBc = chat.bubbleCount || 0;
+    if (!force && cachedTs && cachedTs >= chatTs && cachedBc >= chatBc) {
       // Check if stats exist
       const hasStat = db.prepare('SELECT 1 FROM chat_stats WHERE chat_id = ?').get(chat.composerId);
       if (hasStat) {

package/editors/index.js

@@ -54,4 +54,10 @@ function findChat(idPrefix) {
   return chats.find((c) => c.composerId.startsWith(idPrefix));
 }
 
-module.exports = { getAllChats, getMessages, findChat, editors };
+function resetCaches() {
+  for (const editor of editors) {
+    if (typeof editor.resetCache === 'function') editor.resetCache();
+  }
+}
+
+module.exports = { getAllChats, getMessages, findChat, editors, resetCaches };

package/editors/windsurf.js

@@ -114,6 +114,7 @@ function getChats() {
         mode: 'cascade',
         folder,
         encrypted: false,
+        bubbleCount: summary.stepCount || 0,
         _port: ls.port,
         _csrf: ls.csrf,
         _https: variant.https,
@@ -126,62 +127,213 @@ function getChats() {
   return chats;
 }
 
-function getMessages(chat) {
+function getSteps(chat) {
   if (!chat._port || !chat._csrf) return [];
 
+  // Prefer GetCascadeTrajectorySteps (returns more steps than GetCascadeTrajectory)
+  const resp = callRpc(chat._port, chat._csrf, 'GetCascadeTrajectorySteps', {
+    cascadeId: chat.composerId,
+  }, chat._https);
+  if (resp && resp.steps && resp.steps.length > 0) return resp.steps;
+
+  // Fallback to old method
+  const resp2 = callRpc(chat._port, chat._csrf, 'GetCascadeTrajectory', {
+    cascadeId: chat.composerId,
+  }, chat._https);
+  if (resp2 && resp2.trajectory && resp2.trajectory.steps) return resp2.trajectory.steps;
+
+  return [];
+}
+
+/**
+ * Get the tail messages beyond the step limit using generatorMetadata.
+ * The last generatorMetadata entry with messagePrompts has the conversation context.
+ * We find the overlap with step-based messages by matching the last user message content.
+ */
+function getTailMessages(chat, stepMessages) {
   const resp = callRpc(chat._port, chat._csrf, 'GetCascadeTrajectory', {
     cascadeId: chat.composerId,
   }, chat._https);
-  if (!resp || !resp.trajectory || !resp.trajectory.steps) return [];
+  if (!resp || !resp.trajectory) return [];
 
-  const messages = [];
-  for (const step of resp.trajectory.steps) {
-    const type = step.type || '';
-    const meta = step.metadata || {};
-
-    if (type === 'CORTEX_STEP_TYPE_USER_INPUT' && step.userInput) {
-      messages.push({
-        role: 'user',
-        content: step.userInput.userResponse || step.userInput.items?.map(i => i.text).join('') || '',
-      });
-    } else if (type === 'CORTEX_STEP_TYPE_PLANNER_RESPONSE' && step.plannerResponse) {
-      const pr = step.plannerResponse;
-      const parts = [];
-      if (pr.thinking) parts.push(`[thinking] ${pr.thinking}`);
-      // Text content: prefer modifiedResponse > response > textContent
-      const text = pr.modifiedResponse || pr.response || pr.textContent || '';
-      if (text.trim()) parts.push(text.trim());
-      // Tool calls
-      const _toolCalls = [];
-      if (pr.toolCalls && pr.toolCalls.length > 0) {
-        for (const tc of pr.toolCalls) {
-          let args = {};
-          try { args = tc.argumentsJson ? JSON.parse(tc.argumentsJson) : {}; } catch { args = {}; }
-          const argKeys = typeof args === 'object' ? Object.keys(args).join(', ') : '';
-          parts.push(`[tool-call: ${tc.name}(${argKeys})]`);
-          _toolCalls.push({ name: tc.name, args });
-        }
-      }
-      if (parts.length > 0) {
-        messages.push({
-          role: 'assistant',
-          content: parts.join('\n'),
-          _model: meta.generatorModelUid,
-          _toolCalls,
-        });
+  const gm = resp.trajectory.generatorMetadata || [];
+  // Find the last entry that has messagePrompts
+  let lastWithMsgs = null;
+  for (let i = gm.length - 1; i >= 0; i--) {
+    if (gm[i].chatModel && gm[i].chatModel.messagePrompts && gm[i].chatModel.messagePrompts.length > 0) {
+      lastWithMsgs = gm[i];
+      break;
+    }
+  }
+  if (!lastWithMsgs) return [];
+
+  const mp = lastWithMsgs.chatModel.messagePrompts;
+
+  // Find the last user message from step-based parsing
+  let lastUserContent = '';
+  for (let i = stepMessages.length - 1; i >= 0; i--) {
+    if (stepMessages[i].role === 'user' && stepMessages[i].content.length > 20) {
+      lastUserContent = stepMessages[i].content;
+      break;
+    }
+  }
+  if (!lastUserContent) return [];
+
+  // Find this message in the messagePrompts (search from end for efficiency)
+  const needle = lastUserContent.substring(0, 50);
+  let matchIdx = -1;
+  for (let i = mp.length - 1; i >= 0; i--) {
+    if (mp[i].source === 'CHAT_MESSAGE_SOURCE_USER' && mp[i].prompt && mp[i].prompt.includes(needle)) {
+      matchIdx = i;
+      break;
+    }
+  }
+  if (matchIdx < 0 || matchIdx >= mp.length - 1) return [];
+
+  // Convert everything after the match point to messages
+  const tail = [];
+  for (let i = matchIdx + 1; i < mp.length; i++) {
+    const m = mp[i];
+    const src = m.source || '';
+    const prompt = m.prompt || '';
+    if (!prompt || !prompt.trim()) continue;
+
+    let role;
+    if (src === 'CHAT_MESSAGE_SOURCE_USER') role = 'user';
+    else if (src === 'CHAT_MESSAGE_SOURCE_SYSTEM') role = 'assistant';
+    else if (src === 'CHAT_MESSAGE_SOURCE_TOOL') role = 'tool';
+    else continue;
+
+    tail.push({ role, content: prompt });
+  }
+  return tail;
+}
+
+function parseStep(step) {
+  const type = step.type || '';
+  const meta = step.metadata || {};
+
+  if (type === 'CORTEX_STEP_TYPE_USER_INPUT' && step.userInput) {
+    return {
+      role: 'user',
+      content: step.userInput.userResponse || step.userInput.items?.map(i => i.text).join('') || '',
+    };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_ASK_USER_QUESTION' && step.askUserQuestion) {
+    const q = step.askUserQuestion;
+    return {
+      role: 'user',
+      content: q.userResponse || q.question || '',
+    };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_PLANNER_RESPONSE' && step.plannerResponse) {
+    const pr = step.plannerResponse;
+    const parts = [];
+    if (pr.thinking) parts.push(`[thinking] ${pr.thinking}`);
+    const text = pr.modifiedResponse || pr.response || pr.textContent || '';
+    if (text.trim()) parts.push(text.trim());
+    const _toolCalls = [];
+    if (pr.toolCalls && pr.toolCalls.length > 0) {
+      for (const tc of pr.toolCalls) {
+        let args = {};
+        try { args = tc.argumentsJson ? JSON.parse(tc.argumentsJson) : {}; } catch { args = {}; }
+        const argKeys = typeof args === 'object' ? Object.keys(args).join(', ') : '';
+        parts.push(`[tool-call: ${tc.name}(${argKeys})]`);
+        _toolCalls.push({ name: tc.name, args });
       }
-    } else if (type === 'CORTEX_STEP_TYPE_TOOL_EXECUTION' && step.toolExecution) {
-      const te = step.toolExecution;
-      const toolName = te.toolName || te.name || 'tool';
-      const result = te.output || te.result || '';
-      const preview = typeof result === 'string' ? result.substring(0, 500) : JSON.stringify(result).substring(0, 500);
-      messages.push({
-        role: 'tool',
-        content: `[${toolName}] ${preview}`,
-      });
     }
+    if (parts.length > 0) {
+      return {
+        role: 'assistant',
+        content: parts.join('\n'),
+        _model: meta.generatorModelUid,
+        _toolCalls,
+      };
+    }
+    return null;
+  }
+
+  // Tool-like step types
+  if (type === 'CORTEX_STEP_TYPE_TOOL_EXECUTION' && step.toolExecution) {
+    const te = step.toolExecution;
+    const toolName = te.toolName || te.name || 'tool';
+    const result = te.output || te.result || '';
+    const preview = typeof result === 'string' ? result.substring(0, 500) : JSON.stringify(result).substring(0, 500);
+    return { role: 'tool', content: `[${toolName}] ${preview}` };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_RUN_COMMAND' && step.runCommand) {
+    const rc = step.runCommand;
+    const cmd = rc.command || rc.commandLine || '';
+    const out = (rc.output || rc.stdout || '').substring(0, 500);
+    return { role: 'tool', content: `[run_command] ${cmd}${out ? '\n' + out : ''}` };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_COMMAND_STATUS' && step.commandStatus) {
+    const cs = step.commandStatus;
+    const out = (cs.output || cs.stdout || '').substring(0, 500);
+    return out ? { role: 'tool', content: `[command_status] ${out}` } : null;
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_VIEW_FILE' && step.viewFile) {
+    const vf = step.viewFile;
+    const filePath = vf.filePath || vf.path || '';
+    return { role: 'tool', content: `[view_file] ${filePath}` };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_CODE_ACTION' && step.codeAction) {
+    const ca = step.codeAction;
+    const filePath = ca.filePath || ca.path || '';
+    return { role: 'tool', content: `[code_action] ${filePath}` };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_GREP_SEARCH' && step.grepSearch) {
+    const gs = step.grepSearch;
+    const query = gs.query || gs.pattern || '';
+    return { role: 'tool', content: `[grep_search] ${query}` };
   }
+
+  if (type === 'CORTEX_STEP_TYPE_LIST_DIRECTORY' && step.listDirectory) {
+    const ld = step.listDirectory;
+    const dir = ld.directoryPath || ld.path || '';
+    return { role: 'tool', content: `[list_directory] ${dir}` };
+  }
+
+  if (type === 'CORTEX_STEP_TYPE_MCP_TOOL' && step.mcpTool) {
+    const mt = step.mcpTool;
+    const name = mt.toolName || mt.name || 'mcp_tool';
+    return { role: 'tool', content: `[${name}]` };
+  }
+
+  // Skip non-content steps
+  if (type === 'CORTEX_STEP_TYPE_CHECKPOINT' || type === 'CORTEX_STEP_TYPE_RETRIEVE_MEMORY' ||
+      type === 'CORTEX_STEP_TYPE_MEMORY' || type === 'CORTEX_STEP_TYPE_TODO_LIST' ||
+      type === 'CORTEX_STEP_TYPE_EXIT_PLAN_MODE' || type === 'CORTEX_STEP_TYPE_PROXY_WEB_SERVER') {
+    return null;
+  }
+
+  return null;
+}
+
+function getMessages(chat) {
+  const steps = getSteps(chat);
+  const messages = [];
+  for (const step of steps) {
+    const msg = parseStep(step);
+    if (msg) messages.push(msg);
+  }
+
+  // If steps are truncated, fill in the tail from generatorMetadata
+  const tail = getTailMessages(chat, messages);
+  if (tail.length > 0) {
+    messages.push(...tail);
+  }
+
   return messages;
 }
 
-module.exports = { name, sources, getChats, getMessages };
+function resetCache() { _lsCache = null; }
+
+module.exports = { name, sources, getChats, getMessages, resetCache };

package/index.js

@@ -8,8 +8,120 @@ const { execSync } = require('child_process');
 
 const HOME = os.homedir();
 const PORT = process.env.PORT || 4637;
+const RELAY_PORT = process.env.RELAY_PORT || 4638;
 const noCache = process.argv.includes('--no-cache');
 const collectOnly = process.argv.includes('--collect');
+const isRelay = process.argv.includes('--relay');
+const joinIndex = process.argv.indexOf('--join');
+const isJoin = joinIndex !== -1;
+
+// ── Relay mode ───────────────────────────────────────────────
+if (isRelay) {
+  const { initRelayDb, getRelayDb, createRelayApp } = require('./relay-server');
+  const { wireMcpToExpress } = require('./mcp-server');
+
+  console.log('');
+  console.log(chalk.bold('  ⚡ Agentlytics Relay'));
+  console.log(chalk.dim('  Multi-user context sharing server'));
+  console.log('');
+
+  initRelayDb();
+  console.log(chalk.green('  ✓ Relay database initialized'));
+
+  const app = createRelayApp();
+  wireMcpToExpress(app, getRelayDb);
+  console.log(chalk.green('  ✓ MCP server registered'));
+
+  if (process.env.RELAY_PASSWORD) {
+    console.log(chalk.green('  ✓ Password protection enabled'));
+  } else {
+    console.log(chalk.yellow('  ⚠ No password set (set RELAY_PASSWORD env to protect)'));
+  }
+
+  app.listen(RELAY_PORT, () => {
+    const localIp = getLocalIp();
+    const relayUrl = `http://${localIp}:${RELAY_PORT}`;
+
+    console.log('');
+    console.log(chalk.green(`  ✓ Relay server running on port ${RELAY_PORT}`));
+    console.log('');
+    console.log(chalk.bold('  Share this command with your team:'));
+    console.log('');
+    console.log(chalk.cyan(`    npx agentlytics --join ${localIp}:${RELAY_PORT} --username <name>`));
+    console.log('');
+    console.log(chalk.bold('  MCP server endpoint (add to your AI client):'));
+    console.log('');
+    console.log(chalk.cyan(`    ${relayUrl}/mcp`));
+    console.log('');
+    console.log(chalk.dim('  REST endpoints:'));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/health`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/users`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/search?q=<query>`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/activity/<username>`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/session/<chatId>`));
+    console.log('');
+    console.log(chalk.dim('  Press Ctrl+C to stop'));
+    console.log('');
+  });
+
+  // Skip the rest of the normal flow
+  return;
+}
+
+// ── Join mode ────────────────────────────────────────────────
+if (isJoin) {
+  (async () => {
+    const relayAddress = process.argv[joinIndex + 1];
+    const usernameIndex = process.argv.indexOf('--username');
+    let username = usernameIndex !== -1 ? process.argv[usernameIndex + 1] : null;
+
+    if (!relayAddress) {
+      console.error(chalk.red('\n  ✗ Missing relay address. Usage: npx agentlytics --join <host:port> --username <name>\n'));
+      process.exit(1);
+    }
+
+    // Auto-detect username from git config if not provided
+    if (!username) {
+      try {
+        const gitEmail = execSync('git config user.email', { encoding: 'utf-8' }).trim();
+        if (gitEmail) username = gitEmail;
+      } catch {}
+    }
+
+    // If still no username, ask interactively
+    if (!username) {
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      username = await new Promise(r => {
+        rl.question(chalk.bold('\n  Enter your username: '), (answer) => {
+          rl.close();
+          r(answer.trim());
+        });
+      });
+      if (!username) {
+        console.error(chalk.red('\n  ✗ Username is required.\n'));
+        process.exit(1);
+      }
+    }
+
+    const { startJoinClient } = require('./relay-client');
+    startJoinClient(relayAddress, username);
+  })();
+
+  // Skip the rest of the normal flow
+  return;
+}
+
+// ── Helper: get local IP for relay ───────────────────────────
+function getLocalIp() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) return iface.address;
+    }
+  }
+  return 'localhost';
+}
 
 console.log('');
 console.log(chalk.bold('  ⚡ Agentlytics'));
@@ -96,7 +208,7 @@ console.log(chalk.dim('  Initializing cache database...'));
 cache.initDb();
 
 // Scan all editors and populate cache
-console.log(chalk.dim('  Scanning editors: Cursor, Windsurf, Claude Code, VS Code, Zed, Antigravity, OpenCode, Codex, Gemini CLI, Copilot CLI, Cursor Agent'));
+console.log(chalk.dim('  Scanning editors: Cursor, Windsurf, Claude Code, VS Code, Zed, Antigravity, OpenCode, Codex, Gemini CLI, Copilot CLI, Cursor Agent, Command Code'));
 const startTime = Date.now();
 const result = cache.scanAll((progress) => {
   process.stdout.write(chalk.dim(`\r  Scanning: ${progress.scanned}/${progress.total} chats (${progress.analyzed} analyzed, ${progress.skipped} cached)`));