agentlytics 0.2.10 → 0.2.12

package/cache.js

@@ -7,7 +7,7 @@ const { calculateCost, getModelPricing, normalizeModelName } = require('./pricin
 
 const CACHE_DIR = path.join(os.homedir(), '.agentlytics');
 const CACHE_DB = path.join(CACHE_DIR, 'cache.db');
-const SCHEMA_VERSION = 6; // bump this when schema changes to auto-revalidate
+const SCHEMA_VERSION = 7; // bump this when schema changes to auto-revalidate
 
 /**
  * Normalize a folder path for consistent storage/lookup.
@@ -154,6 +154,38 @@ function initDb() {
     CREATE INDEX IF NOT EXISTS idx_messages_chat ON messages(chat_id);
     CREATE INDEX IF NOT EXISTS idx_tool_calls_name ON tool_calls(tool_name);
     CREATE INDEX IF NOT EXISTS idx_tool_calls_chat ON tool_calls(chat_id);
+
+    CREATE TABLE IF NOT EXISTS gsd_projects (
+      folder TEXT PRIMARY KEY,
+      name TEXT,
+      description TEXT,
+      milestone TEXT,
+      total_phases INTEGER DEFAULT 0,
+      completed_phases INTEGER DEFAULT 0,
+      active_phase TEXT,
+      todos INTEGER DEFAULT 0,
+      backlog INTEGER DEFAULT 0,
+      notes INTEGER DEFAULT 0,
+      last_modified INTEGER,
+      scanned_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS gsd_phases (
+      id TEXT PRIMARY KEY,
+      folder TEXT NOT NULL,
+      phase_number INTEGER,
+      phase_name TEXT,
+      status TEXT,
+      total_tasks INTEGER DEFAULT 0,
+      completed_tasks INTEGER DEFAULT 0,
+      has_plan INTEGER DEFAULT 0,
+      has_research INTEGER DEFAULT 0,
+      has_verification INTEGER DEFAULT 0,
+      last_modified INTEGER,
+      FOREIGN KEY (folder) REFERENCES gsd_projects(folder)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_gsd_phases_folder ON gsd_phases(folder);
   `);
 
   // Store schema version so future runs can detect mismatches
@@ -358,6 +390,9 @@ function scanAll(onProgress, opts = {}) {
   db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('last_scan', Date.now().toString());
   db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('total_chats', total.toString());
 
+  // GSD scan
+  cacheGSDProjects();
+
   return { total, analyzed, skipped };
 }
 
@@ -643,7 +678,7 @@ function getCachedChat(id) {
     createdAt: chat.created_at,
     lastUpdatedAt: chat.last_updated_at,
     encrypted: !!chat.encrypted,
-    messages: messages.map(m => ({ role: m.role, content: m.content, model: m.model })),
+    messages: messages.map(m => ({ role: m.role, content: m.content, model: m.model, inputTokens: m.input_tokens || 0, outputTokens: m.output_tokens || 0 })),
     stats: parsedStats,
     toolCallDetails,
   };
@@ -839,6 +874,9 @@ async function scanAllAsync(onProgress, opts = {}) {
   db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('last_scan', Date.now().toString());
   db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run('total_chats', total.toString());
 
+  // GSD scan
+  cacheGSDProjects();
+
   return { total, analyzed, skipped };
 }
 
@@ -1300,6 +1338,156 @@ function getCostAnalytics(opts = {}) {
 
 function getDb() { return db; }
 
+// ============================================================
+// GSD cache functions
+// ============================================================
+
+const gsd = require('./editors/gsd');
+
+function cacheGSDProjects() {
+  // Get all unique known folders from chats table
+  const rows = db.prepare('SELECT DISTINCT folder FROM chats WHERE folder IS NOT NULL').all();
+  const knownFolders = rows.map(r => r.folder);
+
+  const projects = gsd.getGSDProjects(knownFolders);
+
+  const insProject = db.prepare(`
+    INSERT OR REPLACE INTO gsd_projects
+      (folder, name, description, milestone, total_phases, completed_phases, active_phase, todos, backlog, notes, last_modified, scanned_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const delPhases = db.prepare('DELETE FROM gsd_phases WHERE folder = ?');
+  const insPhase = db.prepare(`
+    INSERT OR REPLACE INTO gsd_phases
+      (id, folder, phase_number, phase_name, status, total_tasks, completed_tasks, has_plan, has_research, has_verification, last_modified)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  const tx = db.transaction(() => {
+    for (const p of projects) {
+      insProject.run(
+        p.folder, p.name, p.description, p.milestone,
+        p.totalPhases, p.completedPhases, p.activePhase,
+        p.todos, p.backlog, p.notes,
+        p.lastModified, Date.now()
+      );
+      delPhases.run(p.folder);
+      const phases = gsd.getGSDPhases(p.folder);
+      for (const ph of phases) {
+        const id = `${p.folder}::${ph.phaseDir}`;
+        insPhase.run(
+          id, p.folder, ph.number, ph.name, ph.status,
+          ph.tasks.total, ph.tasks.completed,
+          ph.hasPlan ? 1 : 0,
+          ph.hasResearch ? 1 : 0,
+          ph.hasVerification ? 1 : 0,
+          ph.lastModified
+        );
+      }
+    }
+  });
+  tx();
+}
+
+function getCachedGSDProjects() {
+  const projects = db.prepare('SELECT * FROM gsd_projects ORDER BY last_modified DESC').all();
+  for (const p of projects) {
+    try {
+      const phases = getGSDPhaseTokens(p.folder);
+      p.total_cost = phases.reduce((s, r) => s + (r.cost || 0), 0);
+    } catch {
+      p.total_cost = 0;
+    }
+  }
+  return projects;
+}
+
+function getCachedGSDPhases(folder) {
+  return db.prepare('SELECT * FROM gsd_phases WHERE folder = ? ORDER BY phase_number ASC').all(folder);
+}
+
+function getGSDPhaseTokens(folder) {
+  const phases = db.prepare(
+    'SELECT id, phase_number, phase_name, status, last_modified FROM gsd_phases WHERE folder = ? ORDER BY phase_number ASC'
+  ).all(folder);
+
+  if (phases.length === 0) return [];
+
+  // Sort by last_modified to build sequential non-overlapping time windows.
+  // Phases with no last_modified are placed at the end.
+  const byTime = [...phases]
+    .filter(p => p.last_modified)
+    .sort((a, b) => a.last_modified - b.last_modified);
+
+  const windowMap = new Map();
+  for (let i = 0; i < byTime.length; i++) {
+    const start = i === 0 ? 0 : byTime[i - 1].last_modified;
+    const end = i === byTime.length - 1 ? Date.now() : byTime[i].last_modified;
+    windowMap.set(byTime[i].id, { start, end });
+  }
+
+  const stmt = db.prepare(`
+    SELECT cs.total_input_tokens, cs.total_output_tokens,
+           cs.total_cache_read, cs.total_cache_write, cs.models
+    FROM chats c JOIN chat_stats cs ON cs.chat_id = c.id
+    WHERE c.folder = ? AND COALESCE(c.last_updated_at, c.created_at) BETWEEN ? AND ?
+  `);
+
+  return phases.map(ph => {
+    const win = windowMap.get(ph.id);
+    let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0;
+    let sessionCount = 0;
+    const modelFreq = {};
+
+    if (win) {
+      const rows = stmt.all(folder, win.start, win.end);
+      for (const row of rows) {
+        totalInput += row.total_input_tokens || 0;
+        totalOutput += row.total_output_tokens || 0;
+        totalCacheRead += row.total_cache_read || 0;
+        totalCacheWrite += row.total_cache_write || 0;
+        sessionCount++;
+        try {
+          const models = JSON.parse(row.models || '[]');
+          for (const m of models) {
+            const key = typeof m === 'string' ? m : (m && m.model);
+            if (key) modelFreq[key] = (modelFreq[key] || 0) + 1;
+          }
+        } catch { /* skip */ }
+      }
+    }
+
+    const dominantModel = Object.entries(modelFreq).sort((a, b) => b[1] - a[1])[0]?.[0] || null;
+    const cost = dominantModel
+      ? (calculateCost(dominantModel, totalInput, totalOutput, totalCacheRead, totalCacheWrite) || 0)
+      : 0;
+    const totalTokens = totalInput + totalOutput;
+
+    return {
+      id: ph.id,
+      phase_number: ph.phase_number,
+      phase_name: ph.phase_name,
+      status: ph.status,
+      total_tokens: totalTokens,
+      cost,
+      session_count: sessionCount,
+    };
+  });
+}
+
+function getCachedGSDOverview() {
+  const projects = getCachedGSDProjects();
+  const totalProjects = projects.length;
+  const totalPhases = projects.reduce((s, p) => s + p.total_phases, 0);
+  const completedPhases = projects.reduce((s, p) => s + p.completed_phases, 0);
+  const activePhases = projects
+    .filter(p => p.active_phase)
+    .map(p => ({ folder: p.folder, name: p.name, activePhase: p.active_phase }));
+  const executingPhases = db.prepare("SELECT COUNT(*) as c FROM gsd_phases WHERE status = 'executing'").get().c;
+  const plannedPhases = db.prepare("SELECT COUNT(*) as c FROM gsd_phases WHERE status = 'planned'").get().c;
+  return { totalProjects, totalPhases, completedPhases, activePhases, executingPhases, plannedPhases };
+}
+
 module.exports = {
   initDb,
   scanAll,
@@ -1317,4 +1505,9 @@ module.exports = {
   getCostBreakdown,
   getCostAnalytics,
   getDb,
+  cacheGSDProjects,
+  getCachedGSDProjects,
+  getCachedGSDPhases,
+  getCachedGSDOverview,
+  getGSDPhaseTokens,
 };

package/editors/gsd.js

@@ -0,0 +1,366 @@
+const path = require('path');
+const fs = require('fs');
+
+const name = 'gsd';
+const labels = { gsd: 'GSD Workflow' };
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function readFileSafe(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+}
+
+function statSafe(filePath) {
+  try { return fs.statSync(filePath); } catch { return null; }
+}
+
+function countFiles(dir) {
+  try { return fs.readdirSync(dir).filter(f => !f.startsWith('.')).length; } catch { return 0; }
+}
+
+/**
+ * Parse YAML frontmatter from STATE.md.
+ * Returns { status, milestone, stoppedAt, progress } or null.
+ */
+function parseStateMd(content) {
+  if (!content) return null;
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const yaml = m[1];
+  function get(key) {
+    const r = yaml.match(new RegExp(`^${key}:\\s*(.+)`, 'm'));
+    return r ? r[1].trim().replace(/^["']|["']$/g, '') : null;
+  }
+  function getInt(key) { const v = get(key); return v ? parseInt(v) : null; }
+  const progressBlock = yaml.match(/^progress:\s*\n((?:[ \t]+.+\n?)*)/m);
+  let progress = null;
+  if (progressBlock) {
+    const pb = progressBlock[1];
+    function pgGet(key) {
+      const r = pb.match(new RegExp(`${key}:\\s*(\\d+)`));
+      return r ? parseInt(r[1]) : null;
+    }
+    progress = {
+      total_phases: pgGet('total_phases'),
+      completed_phases: pgGet('completed_phases'),
+      total_plans: pgGet('total_plans'),
+      completed_plans: pgGet('completed_plans'),
+    };
+  }
+  return {
+    status: get('status'),
+    milestone: get('milestone'),
+    stoppedAt: get('stopped_at'),
+    lastUpdated: get('last_updated'),
+    progress,
+  };
+}
+
+/**
+ * Parse ROADMAP.md phase checkboxes into a map of phase_number → completed.
+ * Phase lines look like: - [x] **Phase 1: Name** or - [ ] Phase 2: Name
+ */
+function parseRoadmapPhaseStatus(content) {
+  if (!content) return new Map();
+  const statusMap = new Map(); // phase_number (int) → 'completed' | 'planned'
+  for (const line of content.split('\n')) {
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!cbMatch) continue;
+    const text = cbMatch[2];
+    if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+    // Extract phase number from patterns: "Phase 1:", "Phase 01:", "**Phase 2:**"
+    const numMatch = text.match(/phase\s+(\d+)/i);
+    if (!numMatch) continue;
+    const num = parseInt(numMatch[1]);
+    if (!isNaN(num)) {
+      statusMap.set(num, cbMatch[1].toLowerCase() === 'x' ? 'completed' : 'planned');
+    }
+  }
+  return statusMap;
+}
+
+/**
+ * Parse PROJECT.md — first # heading = project name, rest = description.
+ */
+function parseProjectMd(content) {
+  if (!content) return { name: null, description: null };
+  const lines = content.split('\n');
+  let projectName = null;
+  const descLines = [];
+  for (const line of lines) {
+    const h1 = line.match(/^#\s+(.+)/);
+    if (h1 && !projectName) {
+      projectName = h1[1].trim();
+      continue;
+    }
+    if (projectName && line.trim()) descLines.push(line.trim());
+  }
+  return {
+    name: projectName,
+    description: descLines.slice(0, 3).join(' ').substring(0, 300) || null,
+  };
+}
+
+/**
+ * Parse ROADMAP.md for phase completion.
+ * Supports: - [ ] **Phase N: Name** ...  and  - [x] **Phase N: Name** ...
+ * Also supports emoji: ✅ completed, 🚧 in-progress, □ planned
+ */
+function parseRoadmapMd(content) {
+  if (!content) return [];
+  const phases = [];
+  for (const line of content.split('\n')) {
+    // Checkbox style: - [ ] or - [x]
+    // Only count lines that look like phase entries, NOT plan file listings (e.g. "01-01-PLAN.md")
+    const cbMatch = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (cbMatch) {
+      const text = cbMatch[2];
+      // Skip plan file entries like "01-01-PLAN.md — description"
+      if (/\d+-\d+-PLAN\.md/i.test(text) || /PLAN\.md\s*[—–-]/i.test(text)) continue;
+      phases.push({ text: text.replace(/\*\*/g, '').trim(), completed: cbMatch[1].toLowerCase() === 'x' });
+      continue;
+    }
+    // Emoji style: ✅ completed, 🚧 in-progress (milestone-level)
+    const emojiMatch = line.match(/^[-*]\s+(✅|🚧|⬜|□)\s+(.+)/);
+    if (emojiMatch) {
+      phases.push({ text: emojiMatch[2].replace(/\*\*/g, '').trim(), completed: emojiMatch[1] === '✅' });
+    }
+  }
+  return phases;
+}
+
+/**
+ * Detect the currently active milestone name from ROADMAP.md.
+ * Looks for 🚧 milestone entries or the first uncompleted milestone block.
+ */
+function detectActiveMilestone(content) {
+  if (!content) return null;
+  for (const line of content.split('\n')) {
+    const m = line.match(/🚧\s+\*?\*?([^*\n-]+)/);
+    if (m) return m[1].trim().split(' - ')[0].trim();
+    // Also handle "in progress" text
+    if (/in.progress/i.test(line)) {
+      const nm = line.match(/\*?\*?([vV][\d.]+[^*]*)\*?\*?/);
+      if (nm) return nm[1].trim();
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract phase number prefix from a phase directory name.
+ * e.g. "01-auth-ve-giris" → "01"
+ * e.g. "999.1-backlog-item" → "999.1"
+ */
+function extractPhasePrefix(dirName) {
+  const m = dirName.match(/^(\d+(?:\.\d+)?)-/);
+  return m ? m[1] : null;
+}
+
+/**
+ * Parse checkbox tasks from a PLAN.md file.
+ */
+function parseCheckboxes(content) {
+  if (!content) return { total: 0, completed: 0, tasks: [] };
+  const tasks = [];
+  for (const line of content.split('\n')) {
+    const m = line.match(/^[-*]\s+\[([x ])\]\s+(.+)/i);
+    if (!m) continue;
+    tasks.push({ name: m[2].trim(), completed: m[1].toLowerCase() === 'x' });
+  }
+  return { total: tasks.length, completed: tasks.filter(t => t.completed).length, tasks };
+}
+
+// ============================================================
+// Public API
+// ============================================================
+
+/**
+ * Scan known project folders for GSD .planning/ directories.
+ * Returns project-level summary for each GSD project found.
+ */
+function getGSDProjects(knownFolders) {
+  const results = [];
+
+  for (const folder of knownFolders) {
+    if (!folder) continue;
+    const planningDir = path.join(folder, '.planning');
+    if (!fs.existsSync(planningDir)) continue;
+
+    // Must have at least PROJECT.md or ROADMAP.md to be a GSD project
+    const hasProject = fs.existsSync(path.join(planningDir, 'PROJECT.md'));
+    const hasRoadmap = fs.existsSync(path.join(planningDir, 'ROADMAP.md'));
+    if (!hasProject && !hasRoadmap) continue;
+
+    const projectContent = readFileSafe(path.join(planningDir, 'PROJECT.md'));
+    const roadmapContent = readFileSafe(path.join(planningDir, 'ROADMAP.md'));
+    const stateContent = readFileSafe(path.join(planningDir, 'STATE.md'));
+    const stateData = parseStateMd(stateContent);
+
+    const { name: projectName, description } = parseProjectMd(projectContent);
+
+    // Use filesystem as source of truth for phase counts
+    // Filter out malformed directory names (e.g. dirs with JSON content in name)
+    const phases = getGSDPhases(folder, roadmapContent);
+    const validPhases = phases.filter(ph => ph.number !== null);
+
+    const totalPhases = validPhases.length;
+    const completedPhases = validPhases.filter(p => p.status === 'completed').length;
+    const firstIncomplete = validPhases.find(p => p.status !== 'completed');
+    const activePhase = stateData?.stoppedAt || (firstIncomplete ? firstIncomplete.name : null);
+
+    // Prefer STATE.md milestone, fallback to ROADMAP detection
+    const activeMilestone = stateData?.milestone || detectActiveMilestone(roadmapContent);
+
+    // Count todos/seeds/quick (common GSD directories)
+    const todos = countFiles(path.join(planningDir, 'todos'))
+      + countFiles(path.join(planningDir, 'seeds'));
+    const notes = countFiles(path.join(planningDir, 'quick'));
+    const backlog = countFiles(path.join(planningDir, 'backlog'));
+
+    const planStat = statSafe(planningDir);
+    const lastModified = planStat ? Math.round(planStat.mtimeMs) : null;
+
+    results.push({
+      folder,
+      name: projectName || path.basename(folder),
+      description,
+      milestone: activeMilestone,
+      totalPhases,
+      completedPhases,
+      activePhase,
+      todos,
+      backlog,
+      notes,
+      lastModified,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Return phase details for a single GSD project.
+ * Phases live in .planning/phases/<phaseDir>/
+ * roadmapContent is optionally passed to cross-reference checkbox status.
+ */
+function getGSDPhases(folder, roadmapContent) {
+  if (roadmapContent === undefined) {
+    roadmapContent = readFileSafe(path.join(folder, '.planning', 'ROADMAP.md'));
+  }
+  const roadmapStatus = parseRoadmapPhaseStatus(roadmapContent);
+  const phasesDir = path.join(folder, '.planning', 'phases');
+  let phaseDirs;
+  try {
+    phaseDirs = fs.readdirSync(phasesDir)
+      .filter(f => {
+        try { return fs.statSync(path.join(phasesDir, f)).isDirectory(); } catch { return false; }
+      })
+      .sort((a, b) => {
+        // Sort by numeric prefix (supports decimals like 999.1)
+        const na = parseFloat(extractPhasePrefix(a) || '9999');
+        const nb = parseFloat(extractPhasePrefix(b) || '9999');
+        return na - nb;
+      });
+  } catch { return []; }
+
+  const phases = [];
+  for (const phaseDir of phaseDirs) {
+    const phaseFullDir = path.join(phasesDir, phaseDir);
+    const prefix = extractPhasePrefix(phaseDir);
+
+    // Phase name: everything after the leading number prefix
+    const nameRaw = phaseDir.replace(/^\d+(?:\.\d+)?-/, '').replace(/-/g, ' ');
+    const phaseName = nameRaw.length > 0 ? nameRaw : phaseDir;
+
+    // Phase number (numeric value for display)
+    const phaseNumber = prefix ? parseFloat(prefix) : null;
+
+    // Detect artifact files using the phase prefix pattern
+    let hasPlan = false, hasResearch = false, hasVerification = false;
+    let planCount = 0, summaryCount = 0;
+    let latestMtime = 0;
+
+    try {
+      const files = fs.readdirSync(phaseFullDir);
+      for (const f of files) {
+        const fPath = path.join(phaseFullDir, f);
+        const st = statSafe(fPath);
+        if (st && st.mtimeMs > latestMtime) latestMtime = st.mtimeMs;
+
+        // PLAN files: {prefix}-{n}-PLAN.md
+        if (f.match(/PLAN\.md$/i)) { hasPlan = true; planCount++; }
+        // SUMMARY files: indicates a plan was executed
+        if (f.match(/SUMMARY\.md$/i)) summaryCount++;
+        // VERIFICATION
+        if (f.match(/VERIFICATION\.md$/i)) hasVerification = true;
+        // RESEARCH
+        if (f.match(/RESEARCH\.md$/i)) hasResearch = true;
+      }
+    } catch { /* skip */ }
+
+    // Determine status: file-based first, then cross-reference ROADMAP.md checkboxes
+    let status = 'planned';
+    if (hasVerification) {
+      status = 'completed';
+    } else if (roadmapStatus.get(phaseNumber) === 'completed') {
+      // ROADMAP.md marks this phase [x] even without VERIFICATION.md
+      status = 'completed';
+    } else if (summaryCount > 0) {
+      status = 'executing';
+    } else if (hasPlan) {
+      status = 'planned';
+    }
+
+    phases.push({
+      phaseDir,
+      number: phaseNumber,
+      name: phaseName,
+      status,
+      tasks: { total: planCount, completed: summaryCount },
+      hasVerification,
+      hasPlan,
+      hasResearch,
+      lastModified: latestMtime || null,
+    });
+  }
+
+  return phases;
+}
+
+/**
+ * Return combined PLAN.md content for a phase.
+ * Aggregates all *-PLAN.md files in order.
+ */
+function getGSDPlanDetail(folder, phaseDir) {
+  const phaseFullDir = path.join(folder, '.planning', 'phases', phaseDir);
+  if (!fs.existsSync(phaseFullDir)) return null;
+
+  let files;
+  try { files = fs.readdirSync(phaseFullDir).filter(f => f.match(/PLAN\.md$/i)).sort(); }
+  catch { return null; }
+  if (files.length === 0) return null;
+
+  const sections = [];
+  const allTasks = [];
+
+  for (const f of files) {
+    const content = readFileSafe(path.join(phaseFullDir, f));
+    if (!content) continue;
+    sections.push(`## ${f}\n\n${content}`);
+    const { tasks } = parseCheckboxes(content);
+    allTasks.push(...tasks);
+  }
+
+  return { content: sections.join('\n\n---\n\n'), tasks: allTasks };
+}
+
+module.exports = {
+  name,
+  labels,
+  getGSDProjects,
+  getGSDPhases,
+  getGSDPlanDetail,
+};

package/index.js

@@ -201,16 +201,30 @@ try {
   require('better-sqlite3');
 } catch (e) {
   if (e.message && e.message.includes('Could not locate the bindings file')) {
-    console.log(chalk.cyan('  ⟳ Rebuilding native SQLite module...'));
+    console.log(chalk.cyan('  ⟳ Native SQLite module not found, downloading prebuilt binary...'));
+    const bsqlDir = path.dirname(require.resolve('better-sqlite3/package.json'));
+    let rebuilt = false;
+    // 1) Use prebuild-install (dep of better-sqlite3) to download a prebuilt binary
     try {
-      const bsqlDir = path.dirname(require.resolve('better-sqlite3/package.json'));
-      execSync('npx --yes prebuild-install -r napi || npx --yes node-gyp rebuild --release', {
-        cwd: bsqlDir, stdio: 'pipe', timeout: 120000,
-      });
-      console.log(chalk.green('  ✓ Native module rebuilt'));
-    } catch (rebuildErr) {
-      console.error(chalk.red('  ✗ Failed to rebuild better-sqlite3:'), rebuildErr.message);
-      console.error(chalk.dim('    Try: npm install better-sqlite3 --build-from-source'));
+      const prebuildBin = require.resolve('prebuild-install/bin.js');
+      execSync(`node "${prebuildBin}" -r napi`, { cwd: bsqlDir, stdio: 'pipe', timeout: 60000 });
+      rebuilt = true;
+    } catch {}
+    // 2) Fallback: compile from source via node-gyp
+    if (!rebuilt) {
+      console.log(chalk.cyan('  ⟳ Prebuilt unavailable, compiling from source...'));
+      try {
+        execSync('npx --yes node-gyp rebuild --release', { cwd: bsqlDir, stdio: 'pipe', timeout: 120000 });
+        rebuilt = true;
+      } catch {}
+    }
+    if (rebuilt) {
+      console.log(chalk.green('  ✓ Native module ready'));
+      // Clear require cache so the freshly built binding is picked up
+      delete require.cache[require.resolve('better-sqlite3')];
+    } else {
+      console.error(chalk.red('  ✗ Failed to build better-sqlite3.'));
+      console.error(chalk.dim('    Ensure build tools are installed (python3, make, g++).'));
       process.exit(1);
     }
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlytics",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Comprehensive analytics dashboard for AI coding agents — Cursor, Windsurf, Claude Code, VS Code Copilot, Zed, Antigravity, OpenCode, Command Code",
   "main": "index.js",
   "bin": {