kodelyth-ecc 1.2.2 → 1.4.0

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

@@ -1,192 +0,0 @@
-// Kodelyth Lens — Codex CLI Reader
-// Reads OpenAI Codex CLI sessions from ~/.codex/state_5.sqlite (primary)
-// and falls back to JSONL/JSON files in sessions/, history/, 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 { execSync }              from 'node:child_process';
-import { detectAgentsInMessages } from '../agent-tracker.js';
-
-const HOME = os.homedir();
-
-export async function readCodexData(dataDir) {
-  const dir = dataDir || process.env.CODEX_DIR || path.join(HOME, '.codex');
-  if (!fs.existsSync(dir)) return { sessions: [], available: false };
-
-  const sessions = [];
-
-  // ── Primary: state_5.sqlite (Codex stores threads here) ─────────────────────
-  const sqliteFile = findSqliteFile(dir);
-  if (sqliteFile) {
-    const sqliteSessions = readSqliteSessions(sqliteFile);
-    sessions.push(...sqliteSessions);
-  }
-
-  // ── Fallback: JSONL / JSON files ─────────────────────────────────────────────
-  if (sessions.length === 0) {
-    for (const subdir of ['sessions', 'history', 'logs', '']) {
-      const target = subdir ? path.join(dir, subdir) : dir;
-      if (!fs.existsSync(target)) continue;
-
-      const files = fs.readdirSync(target).filter(f =>
-        (f.endsWith('.jsonl') || f.endsWith('.json')) && !f.endsWith('.sqlite')
-      );
-
-      for (const file of files) {
-        try {
-          const session = parseCodexJsonFile(path.join(target, file));
-          if (session) sessions.push(session);
-        } catch { /* skip */ }
-      }
-    }
-  }
-
-  sessions.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
-  return { sessions, available: sessions.length > 0 };
-}
-
-// ── SQLite helpers ─────────────────────────────────────────────────────────────
-
-function findSqliteFile(dir) {
-  // Codex v2+ uses state_5.sqlite, older versions used state.sqlite
-  for (const name of ['state_5.sqlite', 'state.sqlite', 'sessions.sqlite']) {
-    const p = path.join(dir, name);
-    if (fs.existsSync(p)) return p;
-  }
-  return null;
-}
-
-function sqlite3Available() {
-  try {
-    execSync('sqlite3 --version', { stdio: 'pipe', timeout: 3000 });
-    return true;
-  } catch { return false; }
-}
-
-function querySqliteJson(dbPath, sql) {
-  try {
-    // Use -json mode: handles | and newlines in content safely
-    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 readSqliteSessions(dbPath) {
-  if (!sqlite3Available()) return [];
-
-  // Query the threads table — primary source of Codex sessions
-  const rows = querySqliteJson(
-    dbPath,
-    'SELECT id, created_at, title, model, cwd, COALESCE(tokens_used, 0) AS tokens_used FROM threads ORDER BY created_at DESC'
-  );
-
-  return rows.map(row => {
-    // created_at is Unix seconds (10 digits)
-    const tsMs = row.created_at
-      ? parseInt(row.created_at, 10) * 1000
-      : Date.now();
-    const ts     = new Date(tsMs).toISOString();
-    const tokens = parseInt(row.tokens_used, 10) || 0;
-
-    // Use title for agent detection (doesn't expose raw user messages in UI)
-    const messages = [
-      row.title        ? { role: 'user', content: row.title,              timestamp: ts } : null,
-      row.first_user_message ? { role: 'user', content: row.first_user_message, timestamp: ts } : null,
-    ].filter(Boolean);
-
-    const agents = detectAgentsInMessages(messages);
-
-    // Safe project label (strip path, no secrets)
-    const project = row.cwd ? path.basename(row.cwd) : 'codex';
-    const titleSafe = (row.title || '').slice(0, 80).replace(/\n/g, ' ');
-
-    return {
-      id:           row.id || path.basename(dbPath),
-      platform:     'codex',
-      project,
-      date:         ts.slice(0, 10),
-      lastDate:     ts.slice(0, 10),
-      timestamp:    ts,
-      lastActivity: ts,
-      title:        titleSafe || 'Codex session',
-      model:        row.model || 'gpt',
-      tokens: {
-        input:      Math.round(tokens * 0.7),
-        output:     Math.round(tokens * 0.3),
-        cacheRead:  0,
-        cacheWrite: 0,
-        total:      tokens,
-      },
-      cost:         estimateCost(tokens),
-      cacheSaved:   0,
-      messageCount: 1,
-      agents,
-      agentCalls:   agents.length,
-    };
-  });
-}
-
-// ── JSONL / JSON fallback ──────────────────────────────────────────────────────
-
-function parseCodexJsonFile(filePath) {
-  const raw = fs.readFileSync(filePath, 'utf-8').trim();
-  if (!raw) return null;
-
-  const messages = [];
-  let firstTs = null;
-
-  for (const line of raw.split('\n').filter(Boolean)) {
-    try {
-      const entry   = JSON.parse(line);
-      const ts      = entry.timestamp || entry.created_at || null;
-      if (ts && !firstTs) firstTs = ts;
-      const role    = entry.role || (entry.type === 'input' ? 'user' : 'assistant');
-      const content = entry.content || entry.message || entry.text || '';
-      if (content) messages.push({ role, content, timestamp: ts });
-    } catch { /* skip */ }
-  }
-
-  if (!messages.length) {
-    try {
-      const data  = JSON.parse(raw);
-      const items = data.messages || data.history || [];
-      for (const item of items) {
-        const ts = item.timestamp || null;
-        if (ts && !firstTs) firstTs = ts;
-        messages.push({ role: item.role || 'user', content: item.content || item.text || '', timestamp: ts });
-      }
-      if (!firstTs) firstTs = data.timestamp || data.created_at || null;
-    } catch { /* skip */ }
-  }
-
-  if (!messages.length) return null;
-
-  const ts     = firstTs || new Date().toISOString();
-  const agents = detectAgentsInMessages(messages);
-
-  return {
-    id:           path.basename(filePath),
-    platform:     'codex',
-    project:      path.basename(filePath),
-    date:         ts.slice(0, 10),
-    timestamp:    ts,
-    tokens:       { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    cost:         0,
-    cacheSaved:   0,
-    messageCount: messages.length,
-    agents,
-    agentCalls:   agents.length,
-  };
-}
-
-function estimateCost(tokens) {
-  // Codex/GPT-5.3 pricing approximation: $2/M input, $8/M output
-  const inputCost  = (tokens * 0.7 / 1_000_000) * 2;
-  const outputCost = (tokens * 0.3 / 1_000_000) * 8;
-  return Math.round((inputCost + outputCost) * 10000) / 10000;
-}

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

@@ -1,135 +0,0 @@
-// Kodelyth Lens — Cursor Reader
-// Reads Cursor session/conversation 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';
-import { tokensToCost } from '../cost-calculator.js';
-
-const HOME = os.homedir();
-
-export async function readCursorData(dataDir) {
-  const candidates = [
-    dataDir,
-    process.env.CURSOR_DIR,
-    path.join(HOME, 'Library', 'Application Support', 'Cursor'),
-    path.join(HOME, 'AppData', 'Roaming', 'Cursor'),
-    path.join(HOME, '.cursor'),
-  ].filter(Boolean);
-
-  const cursorDir = candidates.find(d => d && fs.existsSync(d));
-  if (!cursorDir) return { sessions: [], available: false };
-
-  const sessions = [];
-
-  // Cursor stores workspace state in workspaceStorage
-  const wsDir = path.join(cursorDir, 'User', 'workspaceStorage');
-  if (fs.existsSync(wsDir)) {
-    const wsDirs = fs.readdirSync(wsDir, { withFileTypes: true })
-      .filter(d => d.isDirectory())
-      .map(d => path.join(wsDir, d.name));
-
-    for (const ws of wsDirs) {
-      const session = parseCursorWorkspace(ws);
-      if (session) sessions.push(session);
-    }
-  }
-
-  // Also look for .cursor/chat/ directories in project roots
-  const chatDir = path.join(cursorDir, 'chat');
-  if (fs.existsSync(chatDir)) {
-    const chatFiles = fs.readdirSync(chatDir).filter(f => f.endsWith('.json'));
-    for (const file of chatFiles) {
-      try {
-        const session = parseCursorChatFile(path.join(chatDir, file));
-        if (session) sessions.push(session);
-      } catch { /* skip */ }
-    }
-  }
-
-  sessions.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
-  return { sessions, available: true };
-}
-
-function parseCursorWorkspace(wsDir) {
-  // Look for conversation or chat files
-  const files = fs.readdirSync(wsDir).filter(f =>
-    f.includes('conversation') || f.includes('chat') || f.includes('composer')
-  );
-
-  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 items = data.conversations || data.messages || data.items || [];
-
-      for (const item of items) {
-        if (item.type === 'human' || item.role === 'user') {
-          const ts = item.timestamp || item.createdAt || null;
-          if (ts && !firstTs) firstTs = ts;
-          messages.push({ role: 'user', content: item.text || item.content || '', timestamp: ts });
-        }
-        if (item.type === 'ai' || item.role === 'assistant') {
-          messages.push({ role: 'assistant', content: item.text || item.content || '', timestamp: item.timestamp });
-        }
-      }
-    } catch { /* skip */ }
-  }
-
-  if (!messages.length) return null;
-
-  const agents = detectAgentsInMessages(messages);
-  const ts     = firstTs || new Date().toISOString();
-
-  return {
-    id:           path.basename(wsDir),
-    platform:     'cursor',
-    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 parseCursorChatFile(filePath) {
-  const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-  const messages = (data.messages || []).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:     'cursor',
-    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/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"
-  }
-}