agentlytics 0.1.14 → 0.1.16

package/editors/opencode.js

@@ -1,103 +1,182 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const { execSync } = require('child_process');
 
-const DB_PATH = path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+// OpenCode stores data in different locations depending on the platform
+// - Windows: %LOCALAPPDATA%\opencode\storage (not Roaming)
+// - macOS/Linux: ~/.local/share/opencode/storage (XDG path)
+function getOpenCodeStoragePath() {
+  const home = os.homedir();
+  switch (process.platform) {
+    case 'win32':
+      return path.join(home, 'AppData', 'Local', 'opencode', 'storage');
+    case 'darwin':
+    case 'linux':
+    default:
+      return path.join(home, '.local', 'share', 'opencode', 'storage');
+  }
+}
+
+const STORAGE_DIR = getOpenCodeStoragePath();
+const SESSION_DIR = path.join(STORAGE_DIR, 'session');
+const MESSAGE_DIR = path.join(STORAGE_DIR, 'message');
+const PART_DIR = path.join(STORAGE_DIR, 'part');
 
 // ============================================================
-// Query SQLite via CLI
+// Scan JSON files from OpenCode storage
 // ============================================================
 
-function queryDb(sql) {
-  if (!fs.existsSync(DB_PATH)) return [];
+function readJson(filePath) {
   try {
-    const raw = execSync(
-      `sqlite3 -json ${JSON.stringify(DB_PATH)} ${JSON.stringify(sql)}`,
-      { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'] }
-    );
-    return JSON.parse(raw);
-  } catch { return []; }
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch { return null; }
 }
 
-// ============================================================
-// Adapter interface
-// ============================================================
+function getAllSessions() {
+  const sessions = [];
+  if (!fs.existsSync(SESSION_DIR)) return sessions;
 
-const name = 'opencode';
+  for (const projectHash of fs.readdirSync(SESSION_DIR)) {
+    const projectDir = path.join(SESSION_DIR, projectHash);
+    if (!fs.statSync(projectDir).isDirectory()) continue;
 
-function getChats() {
-  const rows = queryDb('SELECT s.id, s.title, s.directory, s.time_created, s.time_updated, p.worktree, p.name as project_name, (SELECT count(*) FROM message m WHERE m.session_id = s.id) as msg_count FROM session s LEFT JOIN project p ON s.project_id = p.id ORDER BY s.time_updated DESC');
+    let files;
+    try { files = fs.readdirSync(projectDir).filter(f => f.startsWith('ses_') && f.endsWith('.json')); } catch { continue; }
 
-  return rows.map(row => ({
-    source: 'opencode',
-    composerId: row.id,
-    name: cleanTitle(row.title),
-    createdAt: row.time_created,
-    lastUpdatedAt: row.time_updated,
-    mode: 'opencode',
-    folder: row.worktree || row.directory || null,
-    encrypted: false,
-    bubbleCount: row.msg_count || 0,
-  }));
+    for (const file of files) {
+      const filePath = path.join(projectDir, file);
+      const data = readJson(filePath);
+      if (data && data.id) {
+        sessions.push({ ...data, _filePath: filePath });
+      }
+    }
+  }
+  return sessions;
 }
 
-function cleanTitle(title) {
-  if (!title) return null;
-  // Strip default "New session - <date>" titles
-  if (title.startsWith('New session - ')) return null;
-  return title.substring(0, 120) || null;
+function getMessageCount(sessionId) {
+  const sessionMsgDir = path.join(MESSAGE_DIR, sessionId);
+  if (!fs.existsSync(sessionMsgDir)) return 0;
+
+  try {
+    return fs.readdirSync(sessionMsgDir).filter(f => f.startsWith('msg_') && f.endsWith('.json')).length;
+  } catch { return 0; }
 }
 
-function getMessages(chat) {
-  // Get messages with their parts joined
-  const messages = queryDb(`SELECT m.id as msg_id, m.data as msg_data, m.time_created FROM message m WHERE m.session_id = '${chat.composerId}' ORDER BY m.time_created ASC`);
+function getMessagesForSession(sessionId) {
+  const sessionMsgDir = path.join(MESSAGE_DIR, sessionId);
+  if (!fs.existsSync(sessionMsgDir)) return [];
 
-  const result = [];
-  for (const msg of messages) {
-    let msgData;
-    try { msgData = JSON.parse(msg.msg_data); } catch { continue; }
+  let files;
+  try { files = fs.readdirSync(sessionMsgDir).filter(f => f.startsWith('msg_') && f.endsWith('.json')); } catch { return []; }
 
-    const role = msgData.role;
-    if (!role) continue;
+  const messages = [];
+  for (const file of files) {
+    const msgPath = path.join(sessionMsgDir, file);
+    const msg = readJson(msgPath);
+    if (!msg || !msg.id) continue;
 
     // Get parts for this message
-    const parts = queryDb(`SELECT data FROM part WHERE message_id = '${msg.msg_id}' ORDER BY time_created ASC`);
+    const msgPartDir = path.join(PART_DIR, msg.id);
+    const parts = [];
+    if (fs.existsSync(msgPartDir)) {
+      try {
+        const partFiles = fs.readdirSync(msgPartDir).filter(f => f.startsWith('prt_') && f.endsWith('.json'));
+        for (const partFile of partFiles) {
+          const part = readJson(path.join(msgPartDir, partFile));
+          if (part) parts.push(part);
+        }
+      } catch { /* skip */ }
+    }
 
+    // Build content from parts
     const contentParts = [];
     for (const part of parts) {
-      let partData;
-      try { partData = JSON.parse(part.data); } catch { continue; }
-
-      if (partData.type === 'text' && partData.text) {
-        contentParts.push(partData.text);
-      } else if (partData.type === 'tool-use' || partData.type === 'tool_use') {
-        const toolName = partData.name || partData.toolName || 'tool';
-        let argKeys = '';
-        try {
-          const input = typeof partData.input === 'string' ? JSON.parse(partData.input) : (partData.input || {});
-          argKeys = Object.keys(input).join(', ');
-        } catch {}
+      const type = part.type;
+
+      if (type === 'text' && part.text) {
+        contentParts.push(part.text);
+      } else if (type === 'thinking' || type === 'reasoning') {
+        if (part.text) contentParts.push(`[thinking] ${part.text}`);
+      } else if (type === 'tool-call' || type === 'tool_use' || type === 'tool') {
+        const toolName = part.name || part.toolName || part.tool || 'tool';
+        const args = part.args || part.arguments || part.state?.input || {};
+        const argKeys = typeof args === 'object' ? Object.keys(args).join(', ') : '';
         contentParts.push(`[tool-call: ${toolName}(${argKeys})]`);
-      } else if (partData.type === 'tool-result' || partData.type === 'tool_result') {
-        const preview = (partData.text || partData.output || '').substring(0, 500);
+      } else if (type === 'tool-result' || type === 'tool_result') {
+        const preview = (part.text || part.output || part.state?.output || '').substring(0, 500);
         contentParts.push(`[tool-result] ${preview}`);
+      } else if (type === 'step-start' || type === 'step-finish') {
+        // Skip metadata parts
       }
-      // Skip step-start, step-finish (metadata only)
+    }
+
+    // If no parts with content, check if message itself has content
+    if (contentParts.length === 0 && msg.role) {
+      contentParts.push(`[${msg.role}]`);
     }
 
     const content = contentParts.join('\n');
-    if (!content) continue;
-
-    const mappedRole = role === 'user' ? 'user' : role === 'assistant' ? 'assistant' : role;
-    result.push({
-      role: mappedRole,
-      content,
-      _model: msgData.model?.modelID,
-    });
+    if (content) {
+      // Extract model value - handle both string and object formats
+      let modelValue = null;
+      if (typeof msg.modelID === 'string') {
+        modelValue = msg.modelID;
+      } else if (msg.model && typeof msg.model === 'object' && msg.model.modelID) {
+        modelValue = msg.model.modelID;
+      } else if (typeof msg.model === 'string') {
+        modelValue = msg.model;
+      }
+
+      messages.push({
+        role: msg.role || 'assistant',
+        content,
+        _model: modelValue,
+        _inputTokens: msg.tokens?.input,
+        _outputTokens: msg.tokens?.output,
+        _cacheRead: msg.tokens?.cache?.read,
+        _cacheWrite: msg.tokens?.cache?.write,
+        _finish: msg.finish,
+      });
+    }
   }
 
-  return result;
+  // Sort by creation time
+  return messages.sort((a, b) => {
+    const aTime = a.time?.created || 0;
+    const bTime = b.time?.created || 0;
+    return aTime - bTime;
+  });
+}
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'opencode';
+
+function getChats() {
+  const sessions = getAllSessions();
+
+  return sessions.map(s => ({
+    source: 'opencode',
+    composerId: s.id,
+    name: s.title || null,
+    createdAt: s.time?.created || null,
+    lastUpdatedAt: s.time?.updated || null,
+    mode: s.mode || 'opencode',
+    folder: s.directory || null,
+    encrypted: false,
+    bubbleCount: getMessageCount(s.id),
+    _agent: s.agent,
+    _model: s.modelID,
+    _provider: s.providerID,
+    _sessionData: s,
+  })).sort((a, b) => (b.lastUpdatedAt || 0) - (a.lastUpdatedAt || 0));
+}
+
+function getMessages(chat) {
+  return getMessagesForSession(chat.composerId);
 }
 
 const labels = { 'opencode': 'OpenCode' };

package/editors/vscode.js

@@ -315,6 +315,75 @@ function getMessages(chat) {
   return messages;
 }
 
+// ============================================================
+// Usage / quota data from GitHub Copilot internal API
+// ============================================================
+
+function getCopilotToken() {
+  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'));
+    // Pick the first available oauth_token
+    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 creds = getCopilotToken();
+  if (!creds) return null;
+
+  const status = await fetchCopilotStatus(creds.token);
+  if (!status || status.message) return null;
+
+  return {
+    source: 'vscode',
+    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,
+      xcode: status.xcode || false,
+      mcp: status.mcp || false,
+    },
+    limits: {
+      quotas: status.limited_user_quotas || null,
+      resetDate: status.limited_user_reset_date || null,
+    },
+    user: {
+      login: creds.user || null,
+    },
+  };
+}
+
 const labels = { 'vscode': 'VS Code', 'vscode-insiders': 'VS Code Insiders' };
 
-module.exports = { name, labels, getChats, getMessages };
+module.exports = { name, labels, getChats, getMessages, getUsage };