kodelyth-ecc 1.2.0

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

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

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

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

@@ -0,0 +1,135 @@
+// 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,
+  };
+}