kodelyth-ecc 1.2.2 → 1.3.0

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

@@ -1,201 +0,0 @@
-// 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

@@ -1,146 +0,0 @@
-// Kodelyth Lens — Windsurf Reader
-// Reads Windsurf (Codeium) real quota data from state.vscdb SQLite databases
-// 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 { execSync }              from 'node:child_process';
-import { detectAgentsInMessages } from '../agent-tracker.js';
-
-const HOME = os.homedir();
-
-// ── SQLite helpers (same pattern as codex-reader) ──────────────────────────────
-
-function sqlite3Available() {
-  try { execSync('sqlite3 --version', { stdio: 'pipe', timeout: 3000 }); return true; }
-  catch { return false; }
-}
-
-function querySqliteJson(dbPath, sql) {
-  try {
-    const raw = execSync(
-      `sqlite3 -json "${dbPath}" "${sql.replace(/"/g, '\\"')}"`,
-      { stdio: 'pipe', timeout: 5000, encoding: 'utf-8' }
-    ).trim();
-    return raw ? JSON.parse(raw) : [];
-  } catch { return []; }
-}
-
-function readDbKey(dbPath, key) {
-  const rows = querySqliteJson(dbPath, `SELECT value FROM ItemTable WHERE key='${key}'`);
-  if (!rows.length || !rows[0].value) return null;
-  try { return JSON.parse(rows[0].value); } catch { return rows[0].value; }
-}
-
-// ── Find Windsurf data directory ───────────────────────────────────────────────
-
-function findWindsurfDir(override) {
-  return [
-    override,
-    process.env.WINDSURF_DIR,
-    path.join(HOME, 'Library', 'Application Support', 'Windsurf'),
-    path.join(HOME, 'AppData', 'Roaming', 'Windsurf'),
-    path.join(HOME, '.codeium', 'windsurf'),
-  ].filter(Boolean).find(d => fs.existsSync(d)) || null;
-}
-
-// ── Main reader ────────────────────────────────────────────────────────────────
-
-export async function readWindsurfData(dataDir) {
-  const windsurfDir = findWindsurfDir(dataDir);
-  if (!windsurfDir) return { sessions: [], available: false, quotaData: null };
-
-  const hasSqlite = sqlite3Available();
-  let quotaData   = null;
-
-  // ── 1. Read real quota / plan info from global state.vscdb ─────────────────
-  const globalDb = path.join(windsurfDir, 'User', 'globalStorage', 'state.vscdb');
-  if (hasSqlite && fs.existsSync(globalDb)) {
-    const plan = readDbKey(globalDb, 'windsurf.settings.cachedPlanInfo');
-    if (plan?.usage) {
-      const daily  = plan.quotaUsage?.dailyRemainingPercent  ?? 100;
-      const weekly = plan.quotaUsage?.weeklyRemainingPercent ?? 100;
-      quotaData = {
-        planName:              plan.planName || 'Unknown',
-        usedMessages:          plan.usage.usedMessages    || 0,
-        totalMessages:         plan.usage.messages        || 0,
-        usedFlowActions:       plan.usage.usedFlowActions || 0,
-        totalFlowActions:      plan.usage.flowActions     || 0,
-        dailyUsedPercent:      Math.round(100 - daily),
-        weeklyUsedPercent:     Math.round(100 - weekly),
-        dailyRemainingPercent: Math.round(daily),
-        weeklyRemainingPercent:Math.round(weekly),
-        startDate: plan.startTimestamp ? new Date(plan.startTimestamp).toISOString().slice(0, 10) : null,
-        endDate:   plan.endTimestamp   ? new Date(plan.endTimestamp).toISOString().slice(0, 10)   : null,
-      };
-    }
-  }
-
-  // ── 2. Read workspace sessions from workspaceStorage SQLite DBs ─────────────
-  const sessions       = [];
-  const wsStorageDir   = path.join(windsurfDir, 'User', 'workspaceStorage');
-
-  if (hasSqlite && fs.existsSync(wsStorageDir)) {
-    const wsDirs = fs.readdirSync(wsStorageDir, { withFileTypes: true })
-      .filter(d => d.isDirectory())
-      .map(d => path.join(wsStorageDir, d.name));
-
-    for (const wsDir of wsDirs) {
-      const db = path.join(wsDir, 'state.vscdb');
-      if (!fs.existsSync(db)) continue;
-
-      // Determine timestamp: readDateBaseline2 → epoch dirname → skip
-      const baseline = readDbKey(db, 'agentSessions.readDateBaseline2');
-      const dirName  = path.basename(wsDir);
-      let ts = null;
-      if (baseline && !isNaN(parseInt(baseline, 10))) {
-        ts = new Date(parseInt(baseline, 10)).toISOString();
-      } else if (/^\d{13}$/.test(dirName)) {
-        ts = new Date(parseInt(dirName, 10)).toISOString();
-      }
-      if (!ts) continue;
-
-      // Resolve project name from workspace.json
-      let projectName = dirName;
-      const wsJson = path.join(wsDir, 'workspace.json');
-      if (fs.existsSync(wsJson)) {
-        try {
-          const wd = JSON.parse(fs.readFileSync(wsJson, 'utf-8'));
-          const uri = wd.folder || wd.workspace?.folders?.[0]?.uri || '';
-          if (uri) projectName = path.basename(decodeURIComponent(uri).replace(/\/$/, ''));
-        } catch { /* skip */ }
-      }
-
-      // Check for any agent usage in this workspace
-      const agentCache = readDbKey(db, 'agentSessions.state.cache') || [];
-      const messages   = Array.isArray(agentCache)
-        ? agentCache.flatMap(s => (s.messages || []).map(m => ({
-            role:    m.role || 'user',
-            content: m.content || m.text || '',
-          })))
-        : [];
-      const agents = detectAgentsInMessages(messages);
-
-      sessions.push({
-        id:           dirName,
-        platform:     'windsurf',
-        project:      projectName,
-        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:         null,       // Windsurf is quota-based, not per-token
-        cacheSaved:   0,
-        messageCount: messages.length,
-        agents,
-        agentCalls:   agents.length,
-        cloudAI:      true,
-      });
-    }
-  }
-
-  sessions.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
-  return { sessions, available: true, quotaData };
-}

package/dashboard/package.json

@@ -1,24 +0,0 @@
-{
-  "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"
-  }
-}