kodelyth-ecc 1.2.2 → 1.4.0

package/dashboard/lib/aggregator.js

@@ -1,119 +0,0 @@
-// Kodelyth Lens — Data Aggregator
-// Merges data from all platforms into unified stats
-// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
-
-import { detectPlatforms } from './platform-detector.js';
-import { readClaudeData }       from './readers/claude-reader.js';
-import { readCursorData }       from './readers/cursor-reader.js';
-import { readWindsurfData }     from './readers/windsurf-reader.js';
-import { readCodexData }        from './readers/codex-reader.js';
-import { readOpenCodeData }     from './readers/opencode-reader.js';
-import { readAntigravityData }  from './readers/antigravity-reader.js';
-import { buildAgentLeaderboard } from './agent-tracker.js';
-import { buildDailyCosts, cacheSavings } from './cost-calculator.js';
-
-export async function aggregateAll() {
-  const platforms = detectPlatforms();
-
-  // Read all platforms in parallel, never crash if one fails
-  const [claude, cursor, windsurf, codex, opencode, antigravity] = await Promise.all([
-    platforms.claude.installed      ? readClaudeData(platforms.claude.dataDir).catch(() => ({ sessions: [] }))           : { sessions: [] },
-    platforms.cursor.installed      ? readCursorData(platforms.cursor.dataDir).catch(() => ({ sessions: [] }))           : { sessions: [] },
-    platforms.windsurf.installed    ? readWindsurfData(platforms.windsurf.dataDir).catch(() => ({ sessions: [] }))       : { sessions: [] },
-    platforms.codex.installed       ? readCodexData(platforms.codex.dataDir).catch(() => ({ sessions: [] }))             : { sessions: [] },
-    platforms.opencode.installed    ? readOpenCodeData(platforms.opencode.dataDir).catch(() => ({ sessions: [] }))       : { sessions: [] },
-    platforms.antigravity.installed ? readAntigravityData(platforms.antigravity.dataDir).catch(() => ({ sessions: [] })) : { sessions: [] },
-  ]);
-
-  const allSessions = [
-    ...claude.sessions,
-    ...cursor.sessions,
-    ...windsurf.sessions,
-    ...codex.sessions,
-    ...opencode.sessions,
-    ...antigravity.sessions,
-  ].sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
-
-  const today = new Date().toISOString().slice(0, 10);
-  // A session counts as "today" if it started today OR was last active today
-  // (long-running sessions that span multiple days still appear in today's stats)
-  const todaySessions = allSessions.filter(s => s.date === today || s.lastDate === today);
-
-  const totalCacheSaved = allSessions.reduce((n, s) => n + (s.cacheSaved || 0), 0);
-
-  const stats = {
-    today: {
-      sessions:   todaySessions.length,
-      tokens:     sumField(todaySessions, 'tokens.total'),
-      cost:       round(sumField(todaySessions, 'cost')),
-      agentCalls: sumField(todaySessions, 'agentCalls'),
-    },
-    allTime: {
-      sessions:    allSessions.length,
-      tokens:      sumField(allSessions, 'tokens.total'),
-      cost:        round(sumField(allSessions, 'cost')),
-      agentCalls:  sumField(allSessions, 'agentCalls'),
-      cacheSaved:  round(totalCacheSaved),
-      cacheHitRate: calcCacheHitRate(allSessions),
-    },
-  };
-
-  const platformStats = buildPlatformStats(allSessions, platforms);
-  const agents        = buildAgentLeaderboard(allSessions);
-  const dailyCosts    = buildDailyCosts(allSessions);
-
-  return {
-    stats,
-    agents,
-    sessions:  allSessions.slice(0, 100),
-    costs:     dailyCosts,
-    platforms: platformStats,
-    windsurf:  { quotaData: windsurf.quotaData || null },
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-function sumField(arr, field) {
-  return arr.reduce((n, s) => {
-    const parts = field.split('.');
-    let val = s;
-    for (const p of parts) val = val?.[p];
-    return n + (Number(val) || 0);
-  }, 0);
-}
-
-function round(n) { return Math.round(n * 10000) / 10000; }
-
-function calcCacheHitRate(sessions) {
-  const totalInput = sumField(sessions, 'tokens.input');
-  const totalRead  = sumField(sessions, 'tokens.cacheRead');
-  if (!totalInput && !totalRead) return 0;
-  return Math.round((totalRead / (totalInput + totalRead)) * 100);
-}
-
-function buildPlatformStats(sessions, platforms) {
-  const map = {};
-  for (const [key, info] of Object.entries(platforms)) {
-    map[key] = {
-      label:     info.label,
-      color:     info.color,
-      installed: info.installed,
-      sessions:  0,
-      tokens:    0,
-      cost:      0,
-      agents:    0,
-    };
-  }
-
-  for (const s of sessions) {
-    const p = map[s.platform];
-    if (!p) continue;
-    p.sessions++;
-    p.tokens += s.tokens?.total || 0;
-    p.cost   += s.cost          || 0;
-    p.agents += s.agentCalls    || 0;
-  }
-
-  for (const p of Object.values(map)) p.cost = round(p.cost);
-  return map;
-}

package/dashboard/lib/cost-calculator.js

@@ -1,50 +0,0 @@
-// Kodelyth Lens — Cost Calculator
-// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
-
-const PRESETS = {
-  anthropic: { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
-  bedrock:   { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
-};
-
-export function getRates() {
-  const preset = process.env.PRICING_PRESET || 'anthropic';
-  const base = PRESETS[preset] || PRESETS.anthropic;
-  return {
-    input:      parseFloat(process.env.RATE_INPUT      || base.input),
-    output:     parseFloat(process.env.RATE_OUTPUT     || base.output),
-    cacheRead:  parseFloat(process.env.RATE_CACHE_READ || base.cacheRead),
-    cacheWrite: parseFloat(process.env.RATE_CACHE_WRITE|| base.cacheWrite),
-  };
-}
-
-export function tokensToCost(tokens) {
-  const r = getRates();
-  return (
-    ((tokens.input      || 0) / 1_000_000) * r.input  +
-    ((tokens.output     || 0) / 1_000_000) * r.output +
-    ((tokens.cacheRead  || 0) / 1_000_000) * r.cacheRead +
-    ((tokens.cacheWrite || 0) / 1_000_000) * r.cacheWrite
-  );
-}
-
-export function cacheSavings(tokens) {
-  const r = getRates();
-  // Savings = what cache reads would have cost as input tokens minus what they actually cost
-  const saved = ((tokens.cacheRead || 0) / 1_000_000) * (r.input - r.cacheRead);
-  return Math.max(0, saved);
-}
-
-export function buildDailyCosts(sessions) {
-  const byDay = {};
-  for (const s of sessions) {
-    const day = s.date;
-    if (!byDay[day]) byDay[day] = { date: day, cost: 0, tokens: 0, sessions: 0, agents: 0 };
-    byDay[day].cost     += s.cost     || 0;
-    byDay[day].tokens   += (s.tokens?.total || 0);
-    byDay[day].sessions += 1;
-    byDay[day].agents   += s.agentCalls || 0;
-  }
-  return Object.values(byDay)
-    .sort((a, b) => a.date.localeCompare(b.date))
-    .slice(-30); // last 30 days
-}

package/dashboard/lib/platform-detector.js

@@ -1,89 +0,0 @@
-// Kodelyth Lens — Platform Detector
-// Auto-detects installed AI coding platforms
-// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-const HOME = os.homedir();
-
-function exists(p) {
-  try { return fs.existsSync(p); } catch { return false; }
-}
-
-export function detectPlatforms() {
-  const appSupport = path.join(HOME, 'Library', 'Application Support'); // macOS
-  const appData    = path.join(HOME, 'AppData', 'Roaming');             // Windows
-
-  return {
-    claude: {
-      installed: exists(path.join(HOME, '.claude')),
-      dataDir: process.env.CLAUDE_DIR || path.join(HOME, '.claude'),
-      label: 'Claude Code',
-      color: '#f97316',
-    },
-    cursor: {
-      installed: exists(path.join(HOME, '.cursor')) ||
-                 exists(path.join(appSupport, 'Cursor')) ||
-                 exists(path.join(appData, 'Cursor')) ||
-                 exists(path.join(HOME, '.config', 'Cursor')),
-      dataDir: process.env.CURSOR_DIR ||
-               (exists(path.join(appSupport, 'Cursor'))
-                 ? path.join(appSupport, 'Cursor')
-                 : exists(path.join(HOME, '.config', 'Cursor'))
-                   ? path.join(HOME, '.config', 'Cursor')
-                   : path.join(HOME, '.cursor')),
-      label: 'Cursor',
-      color: '#3b82f6',
-    },
-    windsurf: {
-      installed: exists(path.join(HOME, '.codeium', 'windsurf')) ||
-                 exists(path.join(appSupport, 'Windsurf')) ||
-                 exists(path.join(appData, 'Windsurf')),
-      dataDir: process.env.WINDSURF_DIR ||
-               (exists(path.join(appSupport, 'Windsurf'))
-                 ? path.join(appSupport, 'Windsurf')
-                 : path.join(HOME, '.codeium', 'windsurf')),
-      label: 'Windsurf',
-      color: '#06b6d4',
-    },
-    codex: {
-      installed: exists(path.join(HOME, '.codex')),
-      dataDir: process.env.CODEX_DIR || path.join(HOME, '.codex'),
-      label: 'Codex CLI',
-      color: '#10b981',
-    },
-    antigravity: {
-      installed: exists(path.join(appSupport, 'Antigravity')) ||
-                 exists(path.join(appData, 'Antigravity')) ||
-                 exists(path.join(HOME, '.antigravity')) ||
-                 exists(path.join(process.cwd(), '.agent')),
-      dataDir: process.env.ANTIGRAVITY_DIR ||
-               (exists(path.join(appSupport, 'Antigravity'))
-                 ? path.join(appSupport, 'Antigravity')
-                 : exists(path.join(appData, 'Antigravity'))
-                   ? path.join(appData, 'Antigravity')
-                   : path.join(HOME, '.antigravity')),
-      label: 'Antigravity',
-      color: '#7c3aed',
-    },
-    opencode: {
-      installed: exists(path.join(HOME, '.opencode')) ||
-                 exists(path.join(HOME, '.config', 'opencode')) ||
-                 exists(path.join(appSupport, 'opencode')) ||
-                 exists(path.join(appData, 'opencode')) ||
-                 exists(path.join(process.cwd(), '.opencode')),
-      dataDir: process.env.OPENCODE_DIR ||
-               (exists(path.join(HOME, '.opencode'))
-                 ? path.join(HOME, '.opencode')
-                 : exists(path.join(HOME, '.config', 'opencode'))
-                   ? path.join(HOME, '.config', 'opencode')
-                   : exists(path.join(appSupport, 'opencode'))
-                     ? path.join(appSupport, 'opencode')
-                     : path.join(process.cwd(), '.opencode')),
-      label: 'OpenCode',
-      color: '#f43f5e',
-    },
-  };
-}

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

@@ -1,113 +0,0 @@
-// Kodelyth Lens — Antigravity Reader
-// Antigravity is Google's AI coding IDE (VSCode fork).
-// It stores AI sessions server-side — no local conversation logs available.
-// This reader detects installed projects and reads workspaceStorage metadata.
-// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
-
-import fs   from 'node:fs';
-import path from 'node:path';
-import os   from 'node:os';
-
-const HOME = os.homedir();
-
-export async function readAntigravityData(dataDir) {
-  const candidates = [
-    dataDir,
-    path.join(HOME, 'Library', 'Application Support', 'Antigravity'),
-    path.join(HOME, 'AppData', 'Roaming', 'Antigravity'),
-    path.join(HOME, '.antigravity'),
-  ].filter(Boolean);
-  const appSupportDir = candidates.find(d => fs.existsSync(d)) || candidates[0];
-  const wsDir = path.join(appSupportDir, 'User', 'workspaceStorage');
-
-  // Scan home dir for .agent/ project folders (ECC installs)
-  const agentProjects = scanAgentProjects();
-
-  // Read workspace metadata from workspaceStorage DBs
-  const workspaces = readWorkspaces(wsDir);
-
-  // Antigravity stores AI conversations server-side — no local session JSONL.
-  // We return synthetic session records for each known project so the
-  // platform shows as "active" in the dashboard with project context.
-  const sessions = buildProjectSessions(agentProjects, workspaces);
-
-  return {
-    sessions,
-    available:      sessions.length > 0,
-    cloudAI:        true, // Flag: AI sessions are server-side
-    projectCount:   agentProjects.length,
-    workspaceCount: workspaces.length,
-  };
-}
-
-function scanAgentProjects() {
-  const projects = [];
-  const searchRoots = [HOME, path.join(HOME, 'Downloads'), path.join(HOME, 'Documents')];
-
-  for (const root of searchRoots) {
-    if (!fs.existsSync(root)) continue;
-    try {
-      const entries = fs.readdirSync(root, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const agentPath = path.join(root, entry.name, '.agent');
-        if (fs.existsSync(agentPath)) {
-          // Check if it has ECC content (not just an empty folder)
-          const hasEcc = fs.existsSync(path.join(agentPath, 'kodelyth-ecc-install-state.json'))
-            || fs.existsSync(path.join(agentPath, 'rules'))
-            || fs.existsSync(path.join(agentPath, 'workflows'));
-          if (hasEcc) {
-            projects.push({
-              name:    entry.name,
-              path:    path.join(root, entry.name),
-              hasEcc:  true,
-            });
-          }
-        }
-      }
-    } catch { /* skip inaccessible directories */ }
-  }
-
-  return projects;
-}
-
-function readWorkspaces(wsDir) {
-  if (!fs.existsSync(wsDir)) return [];
-  const workspaces = [];
-
-  try {
-    const entries = fs.readdirSync(wsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name === 'History') continue;
-      workspaces.push({ id: entry.name });
-    }
-  } catch { /* skip */ }
-
-  return workspaces;
-}
-
-function buildProjectSessions(agentProjects, workspaces) {
-  if (!agentProjects.length && !workspaces.length) return [];
-
-  const now   = new Date().toISOString();
-  const today = now.slice(0, 10);
-
-  // One synthetic session per ECC-enabled project
-  return agentProjects.map(proj => ({
-    id:           `ag-${proj.name}`,
-    platform:     'antigravity',
-    project:      proj.name,
-    date:         today,
-    lastDate:     today,
-    timestamp:    now,
-    lastActivity: now,
-    tokens:       { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    cost:         0,
-    cacheSaved:   0,
-    messageCount: 0,
-    agents:       [],
-    agentCalls:   0,
-    cloudAI:      true, // Conversations are server-side
-    note:         'Antigravity AI sessions are stored server-side',
-  }));
-}

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

@@ -1,135 +0,0 @@
-// Kodelyth Lens — Claude Code Reader
-// Reads session data from ~/.claude/projects/
-// 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 { tokensToCost, cacheSavings } from '../cost-calculator.js';
-import { detectAgentsInMessages } from '../agent-tracker.js';
-
-const HOME = os.homedir();
-
-export async function readClaudeData(dataDir) {
-  const dir = dataDir || process.env.CLAUDE_DIR || path.join(HOME, '.claude');
-  if (!fs.existsSync(dir)) return { sessions: [], available: false };
-
-  const projectsDir = path.join(dir, 'projects');
-  if (!fs.existsSync(projectsDir)) return { sessions: [], available: true };
-
-  const sessions = [];
-  const projectDirs = fs.readdirSync(projectsDir, { withFileTypes: true })
-    .filter(d => d.isDirectory())
-    .map(d => path.join(projectsDir, d.name));
-
-  for (const projectDir of projectDirs) {
-    let files;
-    try { files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl')); }
-    catch { continue; }
-
-    for (const file of files) {
-      try {
-        const session = parseSessionFile(path.join(projectDir, file), projectDir);
-        if (session) sessions.push(session);
-      } catch { /* skip malformed */ }
-    }
-  }
-
-  // Also merge our hook-based tracking file for richer agent data
-  const trackingFile = path.join(dir, 'kodelyth-agent-tracking.jsonl');
-  const hookTracking = readTrackingFile(trackingFile);
-
-  // Enrich sessions with hook tracking data
-  if (hookTracking.length > 0) {
-    mergeHookTracking(sessions, hookTracking);
-  }
-
-  sessions.sort((a, b) => b.timestamp?.localeCompare(a.timestamp));
-  return { sessions, available: true };
-}
-
-function parseSessionFile(filePath, projectDir) {
-  const raw = fs.readFileSync(filePath, 'utf-8').trim();
-  if (!raw) return null;
-
-  const lines = raw.split('\n').filter(Boolean);
-  const messages = [];
-  const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-  let firstTs = null, lastTs = null;
-
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-      if (entry.timestamp) {
-        if (!firstTs) firstTs = entry.timestamp;
-        lastTs = entry.timestamp;
-      }
-
-      // Usage from assistant turns
-      const usage = entry.message?.usage || entry.usage;
-      if (usage) {
-        tokens.input      += usage.input_tokens                  || 0;
-        tokens.output     += usage.output_tokens                 || 0;
-        tokens.cacheRead  += usage.cache_read_input_tokens       || 0;
-        tokens.cacheWrite += usage.cache_creation_input_tokens   || 0;
-      }
-
-      // Collect messages for agent detection
-      const role    = entry.message?.role    || entry.role;
-      const content = entry.message?.content || entry.content;
-      if (role && content) {
-        messages.push({
-          role,
-          content: typeof content === 'string' ? content : JSON.stringify(content),
-          timestamp: entry.timestamp,
-        });
-      }
-    } catch { /* skip */ }
-  }
-
-  if (!firstTs) return null;
-
-  const agents   = detectAgentsInMessages(messages);
-  const cost     = tokensToCost(tokens);
-  const saved    = cacheSavings(tokens);
-  const project  = path.basename(projectDir).replace(/^-+/, '').replace(/-/g, '/');
-
-  return {
-    id:           path.basename(filePath, '.jsonl'),
-    platform:     'claude',
-    project,
-    date:         firstTs.slice(0, 10),
-    lastDate:     lastTs ? lastTs.slice(0, 10) : firstTs.slice(0, 10),
-    timestamp:    firstTs,
-    lastActivity: lastTs,
-    tokens: { ...tokens, total: tokens.input + tokens.output },
-    cost:         round(cost),
-    cacheSaved:   round(saved),
-    messageCount: messages.length,
-    agents,
-    agentCalls:   agents.length,
-  };
-}
-
-function readTrackingFile(filePath) {
-  if (!fs.existsSync(filePath)) return [];
-  return fs.readFileSync(filePath, 'utf-8')
-    .split('\n').filter(Boolean)
-    .map(l => { try { return JSON.parse(l); } catch { return null; } })
-    .filter(Boolean);
-}
-
-function mergeHookTracking(sessions, tracking) {
-  for (const entry of tracking) {
-    const session = sessions.find(s => s.date === entry.date);
-    if (session && entry.agent) {
-      const already = session.agents.some(a => a.agent === entry.agent && a.timestamp === entry.timestamp);
-      if (!already) {
-        session.agents.push({ agent: entry.agent, timestamp: entry.timestamp, role: 'hook' });
-        session.agentCalls++;
-      }
-    }
-  }
-}
-
-function round(n) { return Math.round(n * 10000) / 10000; }