kodelyth-ecc 1.2.2 → 1.3.0

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; }

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,
-  };
-}