kodelyth-ecc 1.2.0

package/dashboard/lib/readers/opencode-reader.js

@@ -0,0 +1,201 @@
+// Kodelyth Lens — OpenCode Reader
+// Reads OpenCode session logs from ~/.opencode/ and project .opencode/
+// OpenCode stores conversations in JSONL and JSON formats
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { detectAgentsInMessages } from '../agent-tracker.js';
+
+const HOME = os.homedir();
+
+export async function readOpenCodeData(dataDir) {
+  // OpenCode may store data in multiple locations
+  const searchDirs = [
+    dataDir,
+    path.join(HOME, '.opencode'),
+    path.join(HOME, '.config', 'opencode'),
+    path.join(HOME, 'Library', 'Application Support', 'opencode'), // macOS
+    path.join(HOME, 'AppData', 'Roaming', 'opencode'),             // Windows
+    path.join(process.cwd(), '.opencode'),                          // project-local
+  ].filter(Boolean);
+
+  const sessions = [];
+
+  for (const dir of searchDirs) {
+    if (!dir || !fs.existsSync(dir)) continue;
+
+    try {
+      await collectSessionsFromDir(dir, sessions);
+    } catch { /* skip inaccessible directories */ }
+  }
+
+  // Deduplicate by id
+  const seen = new Set();
+  const unique = sessions.filter(s => {
+    if (seen.has(s.id)) return false;
+    seen.add(s.id);
+    return true;
+  });
+
+  unique.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+
+  return { sessions: unique, available: unique.length > 0 };
+}
+
+async function collectSessionsFromDir(dir, sessions) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      // Recurse one level into sessions/, conversations/, history/ subdirs
+      const name = entry.name.toLowerCase();
+      if (['sessions', 'conversations', 'history', 'chats', 'logs'].includes(name)) {
+        try {
+          await collectSessionsFromDir(fullPath, sessions);
+        } catch { /* skip */ }
+      }
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+
+    const isJsonl = entry.name.endsWith('.jsonl');
+    const isJson  = entry.name.endsWith('.json');
+    if (!isJsonl && !isJson) continue;
+
+    try {
+      const session = parseOpenCodeFile(fullPath);
+      if (session) sessions.push(session);
+    } catch { /* skip malformed files */ }
+  }
+}
+
+function parseOpenCodeFile(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf-8').trim();
+  if (!raw) return null;
+
+  const messages = [];
+  let firstTs = null;
+  let tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+
+  // ── Try JSONL (line-by-line events) ─────────────────────────────────────────
+  const lines = raw.split('\n').filter(Boolean);
+  let jsonlOk = false;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (typeof entry !== 'object' || !entry) continue;
+
+      // Extract timestamp
+      const ts = entry.timestamp || entry.created_at || entry.time || null;
+      if (ts && !firstTs) firstTs = ts;
+
+      // Extract role + content — OpenCode may use different field names
+      const role = entry.role
+        || (entry.type === 'user' ? 'user' : null)
+        || (entry.type === 'assistant' ? 'assistant' : null)
+        || (entry.sender === 'human' ? 'user' : null)
+        || (entry.sender === 'ai' ? 'assistant' : null)
+        || 'user';
+
+      const content = entry.content
+        || entry.message
+        || entry.text
+        || entry.body
+        || (typeof entry.parts === 'string' ? entry.parts : null)
+        || (Array.isArray(entry.parts)
+            ? entry.parts.map(p => (typeof p === 'string' ? p : p?.text || '')).join(' ')
+            : null)
+        || '';
+
+      if (content) {
+        messages.push({ role, content, timestamp: ts });
+        jsonlOk = true;
+      }
+
+      // Accumulate token usage if present
+      if (entry.usage) {
+        tokens.input     += entry.usage.input_tokens      || entry.usage.prompt_tokens     || 0;
+        tokens.output    += entry.usage.output_tokens     || entry.usage.completion_tokens  || 0;
+        tokens.cacheRead += entry.usage.cache_read_input_tokens  || 0;
+        tokens.cacheWrite+= entry.usage.cache_creation_input_tokens || 0;
+      }
+    } catch { /* not valid JSON line */ }
+  }
+
+  // ── Try single JSON object ───────────────────────────────────────────────────
+  if (!jsonlOk || messages.length === 0) {
+    try {
+      const data = JSON.parse(raw);
+      const items = data.messages
+        || data.history
+        || data.conversation
+        || data.turns
+        || [];
+
+      for (const item of items) {
+        if (!item) continue;
+        const ts = item.timestamp || item.created_at || null;
+        if (ts && !firstTs) firstTs = ts;
+
+        const role = item.role || item.sender || 'user';
+        const content = item.content || item.text || item.message || '';
+
+        if (content) messages.push({ role, content, timestamp: ts });
+      }
+
+      // Top-level usage
+      if (data.usage) {
+        tokens.input  = data.usage.input_tokens  || data.usage.prompt_tokens    || 0;
+        tokens.output = data.usage.output_tokens || data.usage.completion_tokens || 0;
+      }
+
+      // Top-level timestamp
+      if (!firstTs) firstTs = data.timestamp || data.created_at || data.startedAt || null;
+    } catch { /* skip */ }
+  }
+
+  if (messages.length === 0) return null;
+
+  tokens.total = tokens.input + tokens.output;
+
+  const ts     = firstTs || new Date().toISOString();
+  const agents = detectAgentsInMessages(messages);
+
+  return {
+    id:           path.basename(filePath),
+    platform:     'opencode',
+    project:      path.dirname(filePath).split(path.sep).pop() || 'opencode',
+    date:         ts.slice(0, 10),
+    lastDate:     ts.slice(0, 10),
+    timestamp:    ts,
+    lastActivity: ts,
+    tokens,
+    cost:         estimateCost(tokens),
+    cacheSaved:   estimateCacheSavings(tokens),
+    messageCount: messages.length,
+    agents,
+    agentCalls:   agents.length,
+  };
+}
+
+// OpenCode uses Claude/OpenAI models — approximate pricing
+function estimateCost(tokens) {
+  // Sonnet 4 pricing: $3/M input, $15/M output
+  const inputCost  = (tokens.input  / 1_000_000) * 3;
+  const outputCost = (tokens.output / 1_000_000) * 15;
+  const cacheRead  = (tokens.cacheRead / 1_000_000) * 0.3;
+  return Math.round((inputCost + outputCost + cacheRead) * 10000) / 10000;
+}
+
+function estimateCacheSavings(tokens) {
+  // Cache reads are ~10x cheaper than fresh input
+  const fullPrice   = (tokens.cacheRead / 1_000_000) * 3;
+  const cachePrice  = (tokens.cacheRead / 1_000_000) * 0.3;
+  return Math.round((fullPrice - cachePrice) * 10000) / 10000;
+}

package/dashboard/lib/readers/windsurf-reader.js

@@ -0,0 +1,126 @@
+// Kodelyth Lens — Windsurf Reader
+// Reads Windsurf (Codeium) session logs
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { detectAgentsInMessages } from '../agent-tracker.js';
+
+const HOME = os.homedir();
+
+export async function readWindsurfData(dataDir) {
+  const candidates = [
+    dataDir,
+    process.env.WINDSURF_DIR,
+    path.join(HOME, 'Library', 'Application Support', 'Windsurf'),
+    path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),
+    path.join(HOME, '.codeium', 'windsurf'),
+    path.join(HOME, '.windsurf'),
+  ].filter(Boolean);
+
+  const windsurfDir = candidates.find(d => d && fs.existsSync(d));
+  if (!windsurfDir) return { sessions: [], available: false };
+
+  const sessions = [];
+
+  // Windsurf stores session data similar to VS Code extension
+  const storageDir = path.join(windsurfDir, 'User', 'workspaceStorage');
+  if (fs.existsSync(storageDir)) {
+    const wsDirs = fs.readdirSync(storageDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => path.join(storageDir, d.name));
+
+    for (const ws of wsDirs) {
+      const session = parseWindsurfWorkspace(ws);
+      if (session) sessions.push(session);
+    }
+  }
+
+  // Check for Cascade conversation files
+  const cascadeDir = path.join(windsurfDir, 'cascade');
+  if (fs.existsSync(cascadeDir)) {
+    const jsonFiles = fs.readdirSync(cascadeDir).filter(f => f.endsWith('.json'));
+    for (const file of jsonFiles) {
+      try {
+        const session = parseCascadeFile(path.join(cascadeDir, file));
+        if (session) sessions.push(session);
+      } catch { /* skip */ }
+    }
+  }
+
+  sessions.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+  return { sessions, available: sessions.length > 0 };
+}
+
+function parseWindsurfWorkspace(wsDir) {
+  const files = fs.readdirSync(wsDir).filter(f =>
+    f.includes('cascade') || f.includes('chat') || f.includes('conversation')
+  );
+  if (!files.length) return null;
+
+  const messages = [];
+  let firstTs = null;
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(wsDir, file), 'utf-8'));
+      const turns = data.turns || data.messages || data.conversations || [];
+      for (const turn of turns) {
+        const ts = turn.timestamp || turn.createdAt || null;
+        if (ts && !firstTs) firstTs = ts;
+        const role = turn.type === 'human' ? 'user' : (turn.type === 'ai' ? 'assistant' : (turn.role || 'user'));
+        messages.push({ role, content: turn.text || turn.content || '', timestamp: ts });
+      }
+    } catch { /* skip */ }
+  }
+
+  if (!messages.length) return null;
+  const ts     = firstTs || new Date().toISOString();
+  const agents = detectAgentsInMessages(messages);
+
+  return {
+    id:           path.basename(wsDir),
+    platform:     'windsurf',
+    project:      path.basename(wsDir),
+    date:         ts.slice(0, 10),
+    lastDate:     ts.slice(0, 10),
+    timestamp:    ts,
+    lastActivity: ts,
+    tokens:       { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    cost:         0,
+    cacheSaved:   0,
+    messageCount: messages.length,
+    agents,
+    agentCalls:   agents.length,
+  };
+}
+
+function parseCascadeFile(filePath) {
+  const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  const messages = (data.messages || data.turns || []).map(m => ({
+    role:      m.role || (m.type === 'human' ? 'user' : 'assistant'),
+    content:   m.content || m.text || '',
+    timestamp: m.timestamp || null,
+  }));
+
+  if (!messages.length) return null;
+  const ts     = messages[0].timestamp || new Date().toISOString();
+  const agents = detectAgentsInMessages(messages);
+
+  return {
+    id:           path.basename(filePath, '.json'),
+    platform:     'windsurf',
+    project:      path.basename(filePath, '.json'),
+    date:         ts.slice(0, 10),
+    lastDate:     ts.slice(0, 10),
+    timestamp:    ts,
+    lastActivity: ts,
+    tokens:       { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    cost:         0,
+    cacheSaved:   0,
+    messageCount: messages.length,
+    agents,
+    agentCalls:   agents.length,
+  };
+}

package/dashboard/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "kodelyth-lens",
+  "version": "1.2.0",
+  "description": "Kodelyth Lens — AI coding agent usage dashboard for Claude Code, Cursor, Windsurf, Codex, OpenCode, and Antigravity",
+  "type": "module",
+  "main": "server.js",
+  "bin": {
+    "kodelyth-lens": "./server.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["claude-code", "ai-agents", "developer-tools", "kodelyth", "dashboard"],
+  "author": "Kodelyth <github.com/sifxprime>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sifxprime/kodelyth-ecc.git"
+  }
+}