ai-lens 0.6.9 → 0.7.0

package/.commithash

@@ -1 +1 @@
-1e318f3
+7773594

package/bin/ai-lens.js

@@ -13,6 +13,11 @@ switch (command) {
     await remove();
     break;
   }
+  case 'status': {
+    const { default: status } = await import('../cli/status.js');
+    await status();
+    break;
+  }
   case 'version':
   case '--version':
   case '-v': {
@@ -37,6 +42,7 @@ switch (command) {
     console.log('    --no-mcp        Skip MCP server registration');
     console.log('    --mcp-scope S   MCP scope: user, local, or project (default: user)');
     console.log('  remove          Remove AI Lens hooks and client files');
+    console.log('  status          Run diagnostics and generate a status report');
     console.log('  version         Show package version and commit hash');
     process.exit(command ? 1 : 0);
 }

package/cli/init.js

@@ -529,5 +529,64 @@ export default async function init() {
     blank();
   }
 
+  // Quick verification
+  heading('Verification');
+  const finalConfig = readLensConfig();
+  const verifyUrl = finalConfig.serverUrl;
+
+  if (verifyUrl) {
+    // 1. Server reachable?
+    try {
+      const start = Date.now();
+      const health = await getJson(`${verifyUrl}/api/health`);
+      const ms = Date.now() - start;
+      if (health.status === 'ok') {
+        success(`  Server: reachable (${ms}ms)`);
+      } else {
+        warn(`  Server: responded but unexpected status: ${JSON.stringify(health)}`);
+      }
+    } catch (err) {
+      error(`  Server: unreachable — ${err.message}`);
+      info('  Check server URL and make sure the server is running.');
+    }
+
+    // 2. Token valid?
+    if (finalConfig.authToken) {
+      try {
+        const parsed = new URL(`${verifyUrl}/api/dashboard/overview`);
+        const isHttps = parsed.protocol === 'https:';
+        const requestFn = isHttps ? httpsRequest : httpRequest;
+        const status = await new Promise((resolve, reject) => {
+          const req = requestFn({
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: parsed.pathname,
+            method: 'GET',
+            headers: { 'X-Auth-Token': finalConfig.authToken },
+            timeout: 10_000,
+          }, (res) => {
+            res.resume(); // drain
+            resolve(res.statusCode);
+          });
+          req.on('error', reject);
+          req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+          req.end();
+        });
+        if (status === 200) {
+          success('  Token: valid');
+        } else if (status === 401) {
+          error('  Token: invalid (401) — re-run init to re-authenticate');
+        } else {
+          warn(`  Token: unexpected response (HTTP ${status})`);
+        }
+      } catch (err) {
+        warn(`  Token: could not verify — ${err.message}`);
+      }
+    }
+  } else {
+    warn('  No server URL configured — skipping verification');
+  }
+  blank();
+
   detail(`Log: ${getLogPath()}`);
 }

package/cli/status.js

@@ -0,0 +1,466 @@
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+import { getVersionInfo, readLensConfig, detectInstalledTools, analyzeToolHooks, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
+import { DATA_DIR, QUEUE_PATH, LOG_PATH, getGitIdentity } from '../client/config.js';
+import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
+
+// ANSI helpers
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+
+const CHECK = `${GREEN}\u2713${RESET}`;
+const CROSS = `${RED}\u2717${RESET}`;
+
+const REPORT_PATH = join(DATA_DIR, 'status-report.txt');
+
+function maskToken(token) {
+  if (!token || token.length < 20) return token || '(none)';
+  return token.slice(0, 14) + '...' + token.slice(-4);
+}
+
+function execSafe(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', timeout: 5000, ...opts }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function relativeTime(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  if (diff < 0) return 'just now';
+  const secs = Math.floor(diff / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// ---------------------------------------------------------------------------
+// Individual checks — each returns { ok, summary, detail }
+// ---------------------------------------------------------------------------
+
+function checkVersion() {
+  const { version, commit } = getVersionInfo();
+  return {
+    ok: true,
+    summary: `v${version} (${commit})`,
+    detail: `Version: ${version}\nCommit: ${commit}`,
+  };
+}
+
+function checkSystem() {
+  const osVersion = execSafe('sw_vers -productVersion') || execSafe('uname -r') || 'unknown';
+  const arch = execSafe('uname -m') || 'unknown';
+  const nodeVersion = execSafe('node --version') || 'unknown';
+  const platform = process.platform === 'darwin' ? 'macOS' : process.platform;
+  const summary = `${platform} ${osVersion} ${arch}, Node ${nodeVersion}`;
+  return {
+    ok: true,
+    summary,
+    detail: `Platform: ${platform}\nOS version: ${osVersion}\nArchitecture: ${arch}\nNode: ${nodeVersion}`,
+  };
+}
+
+function checkToolVersion(appName) {
+  const plistPath = `/Applications/${appName}.app/Contents/Info.plist`;
+  const version = execSafe(`defaults read "${plistPath}" CFBundleShortVersionString 2>/dev/null`);
+  if (version) {
+    return { ok: true, summary: `v${version}`, detail: `${appName}: v${version}` };
+  }
+  return { ok: null, summary: 'not installed', detail: `${appName}: not installed` };
+}
+
+function checkGitIdentity() {
+  const { name, email } = getGitIdentity();
+  if (name && email) {
+    return { ok: true, summary: `${name} <${email}>`, detail: `Name: ${name}\nEmail: ${email}` };
+  }
+  if (email) {
+    return { ok: true, summary: email, detail: `Email: ${email}\nName: (not set)` };
+  }
+  return { ok: false, summary: 'not configured', detail: 'Git identity not configured (git config user.email)' };
+}
+
+function checkClientFiles() {
+  const dir = join(homedir(), '.ai-lens', 'client');
+  const files = ['capture.js', 'sender.js', 'config.js'];
+  const results = files.map(f => ({ name: f, exists: existsSync(join(dir, f)) }));
+  const found = results.filter(r => r.exists).length;
+  const ok = found === files.length;
+  const detail = results.map(r => `  ${r.exists ? '\u2713' : '\u2717'} ${r.name}`).join('\n');
+  return {
+    ok,
+    summary: ok ? `installed (${found}/${files.length})` : `missing (${found}/${files.length})`,
+    detail: `Client files in ${dir}:\n${detail}`,
+  };
+}
+
+function checkConfig() {
+  const config = readLensConfig();
+  const serverUrl = config.serverUrl || '(default: http://localhost:3000)';
+  const token = maskToken(config.authToken);
+  const projects = config.projects || '(all)';
+  const hasServer = !!config.serverUrl;
+  const hasToken = !!config.authToken;
+  const ok = hasServer && hasToken;
+  return {
+    ok,
+    summary: `serverUrl=${hasServer ? config.serverUrl : '(not set)'}, token=${token}`,
+    detail: `Server URL: ${serverUrl}\nAuth token: ${token}\nProjects: ${projects}\nRaw config: ${JSON.stringify(config, (k, v) => k === 'authToken' && v ? maskToken(v) : v, 2)}`,
+    serverUrl: config.serverUrl,
+    authToken: config.authToken,
+  };
+}
+
+function checkHooks(tool) {
+  const analysis = analyzeToolHooks(tool);
+  const statusMap = {
+    fresh: { ok: null, label: 'no config file' },
+    current: { ok: true, label: 'hooks current' },
+    outdated: { ok: false, label: 'hooks outdated' },
+    absent: { ok: false, label: 'hooks absent' },
+    malformed: { ok: false, label: 'hooks malformed' },
+  };
+  const mapped = statusMap[analysis.status] || { ok: false, label: analysis.status };
+
+  let detail = `Config path: ${tool.configPath}\nStatus: ${analysis.status}`;
+  if (analysis.error) detail += `\nError: ${analysis.error}`;
+
+  // Include full hook config content
+  try {
+    const raw = readFileSync(tool.configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed.hooks) {
+      detail += `\nHook config:\n${JSON.stringify(parsed.hooks, null, 2)}`;
+    }
+  } catch { /* file doesn't exist or isn't valid */ }
+
+  return { ok: mapped.ok, summary: mapped.label, detail };
+}
+
+function checkQueue() {
+  if (!existsSync(QUEUE_PATH)) {
+    return { ok: true, summary: 'empty (0 events)', detail: 'Queue file does not exist (no pending events)' };
+  }
+
+  let lines;
+  try {
+    lines = readFileSync(QUEUE_PATH, 'utf-8').split('\n').filter(Boolean);
+  } catch (err) {
+    return { ok: false, summary: `error reading queue: ${err.message}`, detail: `Error: ${err.message}` };
+  }
+
+  const count = lines.length;
+  const size = statSync(QUEUE_PATH).size;
+  const sizeStr = size < 1024 ? `${size}B` : `${(size / 1024).toFixed(1)}KB`;
+
+  let detail = `Queue: ${QUEUE_PATH}\nEvents: ${count}\nSize: ${sizeStr}`;
+
+  // Show last 3 events (truncated)
+  const last3 = lines.slice(-3);
+  if (last3.length > 0) {
+    detail += '\n\nLast events:';
+    for (const line of last3) {
+      try {
+        const evt = JSON.parse(line);
+        detail += `\n  ${evt.type || 'unknown'} @ ${evt.timestamp || '?'} [${evt.session_id?.slice(0, 8) || '?'}]`;
+      } catch {
+        detail += `\n  (unparseable line, ${line.length} chars)`;
+      }
+    }
+  }
+
+  // Queue with events = something may be stuck
+  const ok = count === 0;
+  return {
+    ok,
+    summary: ok ? 'empty (0 events)' : `${count} events pending (${sizeStr})`,
+    detail,
+    lineCount: count,
+  };
+}
+
+function checkSenderLog() {
+  if (!existsSync(LOG_PATH)) {
+    return { ok: null, summary: 'no log file', detail: 'Sender log does not exist (sender has not run yet)' };
+  }
+
+  let lines;
+  try {
+    lines = readFileSync(LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+  } catch (err) {
+    return { ok: false, summary: `error reading log: ${err.message}`, detail: `Error: ${err.message}` };
+  }
+
+  const last20 = lines.slice(-20);
+  let lastSend = null;
+  let hasErrors = false;
+
+  for (const line of last20) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.msg === 'batch_sent' || entry.msg === 'send_ok') lastSend = entry.ts;
+      if (entry.msg === 'send_error' || entry.msg === 'send_fail' || entry.level === 'error') hasErrors = true;
+    } catch { /* non-JSON line */ }
+  }
+
+  let summary;
+  if (lastSend) {
+    summary = `last send ${relativeTime(lastSend)}`;
+    if (hasErrors) summary += ', recent errors';
+  } else if (hasErrors) {
+    summary = 'recent errors in log';
+  } else {
+    summary = `${lines.length} entries`;
+  }
+
+  return {
+    ok: !hasErrors,
+    summary,
+    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nLast 20 entries:\n${last20.join('\n')}`,
+  };
+}
+
+async function checkServer(serverUrl) {
+  if (!serverUrl) {
+    return { ok: false, summary: 'no server URL configured', detail: 'Cannot check server: no serverUrl in config' };
+  }
+
+  const url = `${serverUrl}/api/health`;
+  const start = Date.now();
+  try {
+    const res = await fetch(url);
+    const latency = Date.now() - start;
+    const body = await res.text();
+    if (res.ok) {
+      return {
+        ok: true,
+        summary: `reachable (${latency}ms)`,
+        detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
+      };
+    }
+    return {
+      ok: false,
+      summary: `HTTP ${res.status} (${latency}ms)`,
+      detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
+    };
+  } catch (err) {
+    const latency = Date.now() - start;
+    return {
+      ok: false,
+      summary: `unreachable (${err.cause?.code || err.message})`,
+      detail: `URL: ${url}\nError: ${err.message}\nLatency: ${latency}ms`,
+    };
+  }
+}
+
+async function checkToken(serverUrl, authToken) {
+  if (!serverUrl || !authToken) {
+    const missing = !serverUrl ? 'server URL' : 'auth token';
+    return { ok: false, summary: `no ${missing} configured`, detail: `Cannot validate token: missing ${missing}` };
+  }
+
+  const url = `${serverUrl}/api/dashboard/overview`;
+  try {
+    const res = await fetch(url, { headers: { 'X-Auth-Token': authToken } });
+    if (res.ok) {
+      return { ok: true, summary: 'valid', detail: `Token validation: ${res.status} OK` };
+    }
+    if (res.status === 401) {
+      return { ok: false, summary: 'invalid (401)', detail: `Token validation: 401 Unauthorized` };
+    }
+    return { ok: false, summary: `HTTP ${res.status}`, detail: `Token validation: unexpected status ${res.status}` };
+  } catch (err) {
+    return { ok: false, summary: `error (${err.message})`, detail: `Token validation error: ${err.message}` };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Report file generation
+// ---------------------------------------------------------------------------
+
+function buildReport(results, timestamp) {
+  const lines = [
+    `AI Lens Status Report`,
+    `Generated: ${timestamp}`,
+    `${'='.repeat(60)}`,
+    '',
+  ];
+
+  for (const r of results) {
+    const icon = r.ok === true ? '\u2713' : r.ok === false ? '\u2717' : '-';
+    lines.push(`[${icon}] ${r.label}: ${r.summary}`);
+    if (r.detail) {
+      for (const dl of r.detail.split('\n')) {
+        lines.push(`    ${dl}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Full config (masked)
+  lines.push(`${'='.repeat(60)}`);
+  lines.push('Full config (~/.ai-lens/config.json):');
+  try {
+    const raw = readFileSync(join(homedir(), '.ai-lens', 'config.json'), 'utf-8');
+    const config = JSON.parse(raw);
+    if (config.authToken) config.authToken = maskToken(config.authToken);
+    lines.push(JSON.stringify(config, null, 2));
+  } catch {
+    lines.push('(not found or unreadable)');
+  }
+  lines.push('');
+
+  // Full hook configs
+  for (const tool of TOOL_CONFIGS) {
+    lines.push(`${'='.repeat(60)}`);
+    lines.push(`${tool.name} hook config (${tool.configPath}):`);
+    try {
+      const raw = readFileSync(tool.configPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      if (parsed.hooks) {
+        lines.push(JSON.stringify(parsed.hooks, null, 2));
+      } else {
+        lines.push('(no hooks section)');
+      }
+    } catch {
+      lines.push('(not found or unreadable)');
+    }
+    lines.push('');
+  }
+
+  // Queue content (up to 100 lines)
+  lines.push(`${'='.repeat(60)}`);
+  lines.push(`Queue (${QUEUE_PATH}):`);
+  try {
+    const queueLines = readFileSync(QUEUE_PATH, 'utf-8').split('\n').filter(Boolean);
+    lines.push(`Total: ${queueLines.length} events`);
+    for (const ql of queueLines.slice(0, 100)) {
+      lines.push(ql);
+    }
+    if (queueLines.length > 100) lines.push(`... (${queueLines.length - 100} more)`);
+  } catch {
+    lines.push('(empty or not found)');
+  }
+  lines.push('');
+
+  // Sender log (last 100 lines)
+  lines.push(`${'='.repeat(60)}`);
+  lines.push(`Sender log (${LOG_PATH}):`);
+  try {
+    const logLines = readFileSync(LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+    lines.push(`Total: ${logLines.length} entries`);
+    for (const ll of logLines.slice(-100)) {
+      lines.push(ll);
+    }
+  } catch {
+    lines.push('(not found)');
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+export default async function status() {
+  const versionResult = checkVersion();
+  initLogger(versionResult.summary);
+
+  const { version, commit } = getVersionInfo();
+  blank();
+  info(`${BOLD}AI Lens Status v${version} (${commit})${RESET}`);
+  info('='.repeat(40));
+  blank();
+
+  const results = [];
+
+  function printLine(label, result) {
+    const icon = result.ok === true ? CHECK : result.ok === false ? CROSS : `${DIM}-${RESET}`;
+    const pad = ' '.repeat(Math.max(1, 17 - label.length));
+    info(`${label}:${pad}${icon} ${result.summary}`);
+    results.push({ label, ...result });
+  }
+
+  // 1. System info
+  const sys = checkSystem();
+  info(`${'System:'}          ${sys.summary}`);
+  results.push({ label: 'System', ...sys });
+
+  // 2. Tool versions
+  const claude = checkToolVersion('Claude');
+  const cursor = checkToolVersion('Cursor');
+  if (claude.ok !== null) {
+    info(`${'Claude Code:'}     ${claude.summary}`);
+    results.push({ label: 'Claude Code version', ...claude });
+  }
+  if (cursor.ok !== null) {
+    info(`${'Cursor:'}          ${cursor.summary}`);
+    results.push({ label: 'Cursor version', ...cursor });
+  }
+
+  // 3. Git identity
+  printLine('Git identity', checkGitIdentity());
+
+  // 4. Client files
+  printLine('Client files', checkClientFiles());
+
+  // 5. Config
+  const configResult = checkConfig();
+  printLine('Config', configResult);
+
+  // 6. Hooks per installed tool
+  const installedTools = detectInstalledTools();
+  for (const tool of installedTools) {
+    printLine(tool.name, checkHooks(tool));
+  }
+  // Also report tools from TOOL_CONFIGS that aren't installed
+  for (const tool of TOOL_CONFIGS) {
+    if (!installedTools.includes(tool)) {
+      const r = { ok: null, summary: 'not installed', detail: `${tool.name} directory not found at ${tool.dirPath}` };
+      printLine(tool.name, r);
+    }
+  }
+
+  // 7. Queue
+  printLine('Queue', checkQueue());
+
+  // 8. Sender log
+  printLine('Sender log', checkSenderLog());
+
+  // 9. Server connectivity
+  const serverUrl = configResult.serverUrl || readLensConfig().serverUrl;
+  const serverResult = await checkServer(serverUrl);
+  printLine('Server', serverResult);
+
+  // 10. Token validity
+  const authToken = configResult.authToken || readLensConfig().authToken;
+  const tokenResult = await checkToken(serverUrl, authToken);
+  printLine('Token', tokenResult);
+
+  // Write report file
+  const timestamp = new Date().toISOString();
+  const report = buildReport(results, timestamp);
+  try {
+    writeFileSync(REPORT_PATH, report);
+    blank();
+    info(`${DIM}Full report \u2192 ${REPORT_PATH}${RESET}`);
+  } catch (err) {
+    blank();
+    error(`Could not write report: ${err.message}`);
+  }
+
+  blank();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.6.9",
+  "version": "0.7.0",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {