@viren/claude-code-dashboard 0.0.2 → 0.0.4

package/src/mcp.mjs

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
 import { join } from "path";
+import { MAX_SESSION_SCAN } from "./constants.mjs";
 
 export function parseUserMcpConfig(content) {
   try {
@@ -46,30 +47,85 @@ export function findPromotionCandidates(servers) {
     .sort((a, b) => b.projects.length - a.projects.length || a.name.localeCompare(b.name));
 }
 
+/**
+ * Scan file-history snapshots for MCP server usage, enriched with project paths
+ * and timestamps from session-meta. Returns a map of server name → metadata.
+ *
+ * Each entry: { name, projects: Set<string>, lastSeen: Date|null }
+ */
 export function scanHistoricalMcpServers(claudeDir) {
-  const historical = new Set();
   const fileHistoryDir = join(claudeDir, "file-history");
-  if (!existsSync(fileHistoryDir)) return [];
-  const MAX_SESSION_DIRS = 200;
-  const MAX_FILES_TOTAL = 1000;
-  let filesRead = 0;
+  if (!existsSync(fileHistoryDir)) return new Map();
+
+  // Build session → { projectPath, startTime } lookup from session-meta
+  const sessionMeta = new Map();
+  const metaDir = join(claudeDir, "usage-data", "session-meta");
+  if (existsSync(metaDir)) {
+    try {
+      for (const file of readdirSync(metaDir)) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const meta = JSON.parse(readFileSync(join(metaDir, file), "utf8"));
+          const sessionId = file.replace(/\.json$/, "");
+          sessionMeta.set(sessionId, {
+            projectPath: meta.project_path || null,
+            startTime: meta.start_time ? new Date(meta.start_time) : null,
+          });
+        } catch {
+          /* skip malformed meta */
+        }
+      }
+    } catch {
+      /* skip unreadable meta dir */
+    }
+  }
+
+  const servers = new Map(); // name → { name, projects: Set, lastSeen: Date|null }
+
   try {
-    const sessionDirs = readdirSync(fileHistoryDir).sort().slice(-MAX_SESSION_DIRS);
+    const sessionDirs = readdirSync(fileHistoryDir).sort().slice(-MAX_SESSION_SCAN);
     for (const sessionDir of sessionDirs) {
-      if (filesRead >= MAX_FILES_TOTAL) break;
       const sessionPath = join(fileHistoryDir, sessionDir);
-      if (!statSync(sessionPath).isDirectory()) continue;
       try {
-        for (const snapFile of readdirSync(sessionPath)) {
-          if (filesRead >= MAX_FILES_TOTAL) break;
-          filesRead++;
-          const snapPath = join(sessionPath, snapFile);
+        if (!statSync(sessionPath).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+
+      const meta = sessionMeta.get(sessionDir);
+      const projectPath = meta?.projectPath || null;
+      const startTime = meta?.startTime || null;
+
+      try {
+        // Only read the latest version of each file hash (highest @vN)
+        const files = readdirSync(sessionPath);
+        const latestByHash = new Map();
+        for (const f of files) {
+          const atIdx = f.indexOf("@v");
+          if (atIdx < 0) continue;
+          const hash = f.slice(0, atIdx);
+          const ver = parseInt(f.slice(atIdx + 2), 10) || 0;
+          const prev = latestByHash.get(hash);
+          if (!prev || ver > prev.ver) {
+            latestByHash.set(hash, { file: f, ver });
+          }
+        }
+
+        for (const { file } of latestByHash.values()) {
+          const snapPath = join(sessionPath, file);
           try {
             const content = readFileSync(snapPath, "utf8");
             if (!content.includes("mcpServers")) continue;
             const data = JSON.parse(content);
             for (const name of Object.keys(data.mcpServers || {})) {
-              historical.add(name);
+              if (!servers.has(name)) {
+                servers.set(name, { name, projects: new Set(), lastSeen: null });
+              }
+              const entry = servers.get(name);
+              if (projectPath) entry.projects.add(projectPath);
+              if (startTime && (!entry.lastSeen || startTime > entry.lastSeen)) {
+                entry.lastSeen = startTime;
+              }
             }
           } catch {
             /* skip malformed */
@@ -82,5 +138,40 @@ export function scanHistoricalMcpServers(claudeDir) {
   } catch {
     /* skip unreadable file-history dir */
   }
-  return [...historical];
+  return servers;
+}
+
+/**
+ * Classify historical MCP servers as "recent" (seen in last recencyDays) or "former".
+ * Recent servers are merged into the current server list if not already present.
+ */
+export function classifyHistoricalServers(
+  historicalMap,
+  currentNames,
+  recencyDays = 30,
+  now = null,
+) {
+  const cutoff = new Date(now || Date.now());
+  cutoff.setDate(cutoff.getDate() - recencyDays);
+
+  const recent = [];
+  const former = [];
+
+  for (const [name, entry] of historicalMap) {
+    if (currentNames.has(name)) continue; // already in current config
+    const info = {
+      name,
+      projects: [...entry.projects].sort(),
+      lastSeen: entry.lastSeen,
+    };
+    if (entry.lastSeen && entry.lastSeen >= cutoff) {
+      recent.push(info);
+    } else {
+      former.push(info);
+    }
+  }
+
+  recent.sort((a, b) => a.name.localeCompare(b.name));
+  former.sort((a, b) => a.name.localeCompare(b.name));
+  return { recent, former };
 }

package/src/render.mjs

@@ -130,6 +130,15 @@ export function renderRepoCard(repo) {
       .join("")}</div>`;
   }
 
+  if (repo.similarRepos && repo.similarRepos.length) {
+    body += `<div class="label">Similar Configs</div>`;
+    body += `<div class="similar-repos">${repo.similarRepos
+      .map(
+        (r) => `<span class="similar-repo">${esc(r.name)} <small>${r.similarity}%</small></span>`,
+      )
+      .join("")}</div>`;
+  }
+
   if (repo.sections.length) {
     body += `<div class="label">Agent Config</div>`;
     body += renderSections(repo.sections);

package/src/watch.mjs

@@ -13,8 +13,8 @@ export function startWatch(outputPath, scanRoots, cliArgs) {
   // and noisy snapshot writes on every file change
   const forwardedArgs = process.argv
     .slice(2)
-    .filter((a) => a !== "--watch" && a !== "--diff")
-    .concat(["--quiet"]);
+    .filter((a) => a !== "--watch" && a !== "--diff" && a !== "--open")
+    .concat(["--quiet", "--no-open"]);
 
   // Resolve output path to detect and ignore self-writes
   const resolvedOutput = resolve(outputPath);