md4ai 0.4.0 → 0.5.1

package/dist/index.bundled.js

@@ -319,14 +319,14 @@ ${deviceName}`) + chalk7.dim(` (${first.os_type})`));
 // dist/commands/map.js
 import { resolve as resolve3 } from "node:path";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import chalk9 from "chalk";
 
 // dist/scanner/index.js
-import { readdir } from "node:fs/promises";
-import { join as join6, relative } from "node:path";
-import { existsSync as existsSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { readdir as readdir2 } from "node:fs/promises";
+import { join as join7, relative } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import { createHash } from "node:crypto";
 
 // dist/scanner/file-parser.js
@@ -582,9 +582,15 @@ function detectOrphans(allFiles, references, rootFiles, projectRoot) {
       sizeBytes = statSync3(fullPath).size;
     } catch {
     }
+    let createdAt = null;
+    try {
+      createdAt = statSync3(fullPath).birthtime.toISOString();
+    } catch {
+    }
     return {
       path: f,
       lastModified: getGitLastModified(fullPath, projectRoot),
+      createdAt,
       sizeBytes
     };
   });
@@ -675,13 +681,255 @@ async function parseSettingsForPlugins(settingsPath, skills, isMachineWide) {
   }
 }
 
+// dist/scanner/tooling-detector.js
+import { readFile as readFile4, readdir } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { homedir as homedir4 } from "node:os";
+var CLI_VERSION_COMMANDS = [
+  { name: "node", command: "node", args: ["--version"] },
+  { name: "npm", command: "npm", args: ["--version"] },
+  { name: "pnpm", command: "pnpm", args: ["--version"], conditionFile: "pnpm-lock.yaml" },
+  { name: "supabase-cli", command: "npx", args: ["supabase", "--version"] },
+  { name: "claude-code", command: "claude", args: ["--version"] }
+];
+async function detectToolings(projectRoot) {
+  const toolings = [];
+  const pkgToolings = await detectFromPackageJson(projectRoot);
+  toolings.push(...pkgToolings);
+  const cliToolings = detectFromCli(projectRoot);
+  toolings.push(...cliToolings);
+  const mcpToolings = await detectFromMcpSettings(projectRoot);
+  toolings.push(...mcpToolings);
+  return toolings;
+}
+async function detectFromPackageJson(projectRoot) {
+  const toolings = [];
+  const pkgPath = join6(projectRoot, "package.json");
+  if (!existsSync4(pkgPath))
+    return toolings;
+  const resolvedVersions = await getResolvedVersions(projectRoot);
+  const seen = /* @__PURE__ */ new Set();
+  const pkgPaths = [pkgPath];
+  const workspacePaths = await discoverWorkspacePackageJsons(projectRoot);
+  pkgPaths.push(...workspacePaths);
+  for (const path of pkgPaths) {
+    try {
+      const content = await readFile4(path, "utf-8");
+      const pkg = JSON.parse(content);
+      const allDeps = {
+        ...pkg.dependencies ?? {},
+        ...pkg.devDependencies ?? {}
+      };
+      for (const [name, specifier] of Object.entries(allDeps)) {
+        if (seen.has(name))
+          continue;
+        seen.add(name);
+        if (specifier.startsWith("workspace:"))
+          continue;
+        const resolved = resolvedVersions.get(name);
+        const version = resolved ?? stripVersionPrefix(specifier);
+        toolings.push({
+          tool_name: name,
+          detected_version: version,
+          detection_source: "package.json"
+        });
+      }
+    } catch {
+    }
+  }
+  return toolings;
+}
+async function discoverWorkspacePackageJsons(projectRoot) {
+  const patterns = await getWorkspacePatterns(projectRoot);
+  if (patterns.length === 0)
+    return [];
+  const results = [];
+  for (const pattern of patterns) {
+    const isGlob = /\/\*\*?$/.test(pattern) || pattern.includes("*");
+    const cleanPattern = pattern.replace(/\/\*\*?$/, "");
+    if (isGlob) {
+      const parentDir = join6(projectRoot, cleanPattern);
+      if (!existsSync4(parentDir))
+        continue;
+      try {
+        const entries = await readdir(parentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          const pkgPath = join6(parentDir, entry.name, "package.json");
+          if (existsSync4(pkgPath)) {
+            results.push(pkgPath);
+          }
+        }
+      } catch {
+      }
+    } else {
+      const pkgPath = join6(projectRoot, cleanPattern, "package.json");
+      if (existsSync4(pkgPath)) {
+        results.push(pkgPath);
+      }
+    }
+  }
+  return results;
+}
+async function getWorkspacePatterns(projectRoot) {
+  const pnpmWorkspace = join6(projectRoot, "pnpm-workspace.yaml");
+  if (existsSync4(pnpmWorkspace)) {
+    try {
+      const content = await readFile4(pnpmWorkspace, "utf-8");
+      const patterns = [];
+      let inPackages = false;
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed === "packages:") {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          if (trimmed.startsWith("- ")) {
+            patterns.push(trimmed.slice(2).replace(/^["']|["']$/g, ""));
+          } else if (trimmed && !trimmed.startsWith("#")) {
+            break;
+          }
+        }
+      }
+      if (patterns.length > 0)
+        return patterns;
+    } catch {
+    }
+  }
+  const pkgPath = join6(projectRoot, "package.json");
+  try {
+    const content = await readFile4(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const workspaces = pkg.workspaces;
+    if (Array.isArray(workspaces))
+      return workspaces;
+    if (workspaces?.packages && Array.isArray(workspaces.packages))
+      return workspaces.packages;
+  } catch {
+  }
+  return [];
+}
+function stripVersionPrefix(version) {
+  return version.replace(/^[\^~>=<]+/, "").split(" ")[0];
+}
+async function getResolvedVersions(projectRoot) {
+  const versions = /* @__PURE__ */ new Map();
+  const pnpmLock = join6(projectRoot, "pnpm-lock.yaml");
+  if (existsSync4(pnpmLock)) {
+    try {
+      const content = await readFile4(pnpmLock, "utf-8");
+      const versionPattern = /^\s{4}'?(@?[^@\s:]+)(?:@[^:]+)?'?:\s*(?:version:\s*)?'?(\d+\.\d+[^'\s]*)/gm;
+      let match;
+      while ((match = versionPattern.exec(content)) !== null) {
+        const [, name, version] = match;
+        if (name && version && !versions.has(name)) {
+          versions.set(name, version);
+        }
+      }
+    } catch {
+    }
+  }
+  if (versions.size === 0) {
+    const npmLock = join6(projectRoot, "package-lock.json");
+    if (existsSync4(npmLock)) {
+      try {
+        const content = await readFile4(npmLock, "utf-8");
+        const lock = JSON.parse(content);
+        const packages = lock.packages ?? lock.dependencies ?? {};
+        for (const [key, value] of Object.entries(packages)) {
+          const name = key.replace(/^node_modules\//, "");
+          const ver = value.version;
+          if (name && ver && !versions.has(name)) {
+            versions.set(name, ver);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return versions;
+}
+function detectFromCli(projectRoot) {
+  const toolings = [];
+  for (const { name, command, args, conditionFile } of CLI_VERSION_COMMANDS) {
+    if (conditionFile && !existsSync4(join6(projectRoot, conditionFile))) {
+      continue;
+    }
+    try {
+      const output = execFileSync3(command, args, {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const firstLine = output.replace(/^v/, "").split("\n")[0].trim();
+      const versionMatch = firstLine.match(/^(\d+\.\d+[^\s]*)/);
+      const version = versionMatch?.[1] ?? firstLine;
+      if (version) {
+        toolings.push({
+          tool_name: name,
+          detected_version: version,
+          detection_source: "cli"
+        });
+      }
+    } catch {
+    }
+  }
+  return toolings;
+}
+async function detectFromMcpSettings(projectRoot) {
+  const toolings = [];
+  const settingsPaths = [
+    join6(projectRoot, ".claude", "settings.json"),
+    join6(projectRoot, ".claude", "settings.local.json"),
+    join6(homedir4(), ".claude", "settings.json")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const settingsPath of settingsPaths) {
+    if (!existsSync4(settingsPath))
+      continue;
+    try {
+      const content = await readFile4(settingsPath, "utf-8");
+      const settings = JSON.parse(content);
+      const mcpServers = settings.mcpServers ?? {};
+      for (const serverName of Object.keys(mcpServers)) {
+        if (seen.has(serverName))
+          continue;
+        seen.add(serverName);
+        let version = null;
+        const config = mcpServers[serverName];
+        if (config?.command && typeof config.command === "string") {
+          const args = config.args ?? [];
+          for (const arg of args) {
+            const versionMatch = arg.match(/@(\d+\.\d+[^\s]*?)$/);
+            if (versionMatch) {
+              version = versionMatch[1];
+              break;
+            }
+          }
+        }
+        toolings.push({
+          tool_name: serverName,
+          detected_version: version,
+          detection_source: "mcp_settings"
+        });
+      }
+    } catch {
+    }
+  }
+  return toolings;
+}
+
 // dist/scanner/index.js
 async function scanProject(projectRoot) {
   const allFiles = await discoverFiles(projectRoot);
   const rootFiles = identifyRoots(allFiles, projectRoot);
   const allRefs = [];
   for (const file of allFiles) {
-    const fullPath = file.startsWith("/") ? file : join6(projectRoot, file);
+    const fullPath = file.startsWith("/") ? file : join7(projectRoot, file);
     try {
       const refs = await parseFileReferences(fullPath, projectRoot);
       allRefs.push(...refs);
@@ -692,39 +940,41 @@ async function scanProject(projectRoot) {
   const orphans = detectOrphans(allFiles, allRefs, rootFiles, projectRoot);
   const staleFiles = detectStaleFiles(allFiles, projectRoot);
   const skills = await parseSkills(projectRoot);
-  const scanData = JSON.stringify({ graph, orphans, skills, staleFiles });
+  const toolings = await detectToolings(projectRoot);
+  const scanData = JSON.stringify({ graph, orphans, skills, staleFiles, toolings });
   const dataHash = createHash("sha256").update(scanData).digest("hex");
   return {
     graph,
     orphans,
     skills,
     staleFiles,
+    toolings,
     scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
     dataHash
   };
 }
 async function discoverFiles(projectRoot) {
   const files = [];
-  const claudeDir = join6(projectRoot, ".claude");
-  if (existsSync4(claudeDir)) {
+  const claudeDir = join7(projectRoot, ".claude");
+  if (existsSync5(claudeDir)) {
     await walkDir(claudeDir, projectRoot, files);
   }
-  if (existsSync4(join6(projectRoot, "CLAUDE.md"))) {
+  if (existsSync5(join7(projectRoot, "CLAUDE.md"))) {
     files.push("CLAUDE.md");
   }
-  if (existsSync4(join6(projectRoot, "skills.md"))) {
+  if (existsSync5(join7(projectRoot, "skills.md"))) {
     files.push("skills.md");
   }
-  const plansDir = join6(projectRoot, "docs", "plans");
-  if (existsSync4(plansDir)) {
+  const plansDir = join7(projectRoot, "docs", "plans");
+  if (existsSync5(plansDir)) {
     await walkDir(plansDir, projectRoot, files);
   }
   return [...new Set(files)];
 }
 async function walkDir(dir, projectRoot, files) {
-  const entries = await readdir(dir, { withFileTypes: true });
+  const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join6(dir, entry.name);
+    const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
       if (["node_modules", ".git", ".turbo", "cache", "session-env"].includes(entry.name))
         continue;
@@ -743,17 +993,17 @@ function identifyRoots(allFiles, projectRoot) {
     }
   }
   for (const globalFile of GLOBAL_ROOT_FILES) {
-    const expanded = globalFile.replace("~", homedir4());
-    if (existsSync4(expanded)) {
+    const expanded = globalFile.replace("~", homedir5());
+    if (existsSync5(expanded)) {
       roots.push(globalFile);
     }
   }
   return roots;
 }
 async function readClaudeConfigFiles(projectRoot) {
-  const { readFile: readFile6, stat, glob } = await import("node:fs/promises");
-  const { join: join10, relative: relative2 } = await import("node:path");
-  const { existsSync: existsSync9 } = await import("node:fs");
+  const { readFile: readFile7, stat, glob } = await import("node:fs/promises");
+  const { join: join11, relative: relative2 } = await import("node:path");
+  const { existsSync: existsSync10 } = await import("node:fs");
   const configPatterns = [
     "CLAUDE.md",
     ".claude/CLAUDE.md",
@@ -763,11 +1013,11 @@ async function readClaudeConfigFiles(projectRoot) {
   ];
   const files = [];
   for (const pattern of configPatterns) {
-    for await (const fullPath of glob(join10(projectRoot, pattern))) {
-      if (!existsSync9(fullPath))
+    for await (const fullPath of glob(join11(projectRoot, pattern))) {
+      if (!existsSync10(fullPath))
         continue;
       try {
-        const content = await readFile6(fullPath, "utf-8");
+        const content = await readFile7(fullPath, "utf-8");
         const fileStat = await stat(fullPath);
         const lastMod = getGitLastModified(fullPath, projectRoot);
         files.push({
@@ -786,7 +1036,7 @@ function detectStaleFiles(allFiles, projectRoot) {
   const stale = [];
   const now = Date.now();
   for (const file of allFiles) {
-    const fullPath = join6(projectRoot, file);
+    const fullPath = join7(projectRoot, file);
     const lastMod = getGitLastModified(fullPath, projectRoot);
     if (lastMod) {
       const days = Math.floor((now - new Date(lastMod).getTime()) / (1e3 * 60 * 60 * 24));
@@ -911,7 +1161,7 @@ function escapeHtml(text) {
 
 // dist/check-update.js
 import chalk8 from "chalk";
-var CURRENT_VERSION = "0.4.0";
+var CURRENT_VERSION = "0.5.1";
 async function checkForUpdate() {
   try {
     const controller = new AbortController();
@@ -954,11 +1204,30 @@ function isNewer(a, b) {
   return false;
 }
 
+// dist/commands/push-toolings.js
+async function pushToolings(supabase, folderId, toolings) {
+  if (!toolings.length)
+    return;
+  const { data: registry } = await supabase.from("tools_registry").select("id, name");
+  const registryMap = new Map((registry ?? []).map((r) => [r.name, r.id]));
+  for (const tooling of toolings) {
+    const toolId = registryMap.get(tooling.tool_name) ?? null;
+    await supabase.from("project_toolings").upsert({
+      folder_id: folderId,
+      tool_id: toolId,
+      tool_name: tooling.tool_name,
+      detected_version: tooling.detected_version,
+      detection_source: tooling.detection_source,
+      detected_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, { onConflict: "folder_id,tool_name,detection_source" });
+  }
+}
+
 // dist/commands/map.js
 async function mapCommand(path, options) {
   await checkForUpdate();
   const projectRoot = resolve3(path ?? process.cwd());
-  if (!existsSync5(projectRoot)) {
+  if (!existsSync6(projectRoot)) {
     console.error(chalk9.red(`Path not found: ${projectRoot}`));
     process.exit(1);
   }
@@ -970,9 +1239,10 @@ async function mapCommand(path, options) {
   console.log(`  Orphans:       ${result.orphans.length}`);
   console.log(`  Stale files:   ${result.staleFiles.length}`);
   console.log(`  Skills:        ${result.skills.length}`);
+  console.log(`  Toolings:      ${result.toolings.length}`);
   console.log(`  Data hash:     ${result.dataHash.slice(0, 12)}...`);
   const outputDir = resolve3(projectRoot, "output");
-  if (!existsSync5(outputDir)) {
+  if (!existsSync6(outputDir)) {
     await mkdir2(outputDir, { recursive: true });
   }
   const htmlPath = resolve3(outputDir, "index.html");
@@ -1030,6 +1300,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
         if (error) {
           console.error(chalk9.yellow(`Sync warning: ${error.message}`));
         } else {
+          await pushToolings(supabase, folder_id, result.toolings);
           await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder_id).eq("device_name", device_name);
           await saveState({
             lastFolderId: folder_id,
@@ -1064,42 +1335,42 @@ ${proposedFiles.length} file(s) proposed for deletion:
 }
 
 // dist/commands/simulate.js
-import { join as join7 } from "node:path";
-import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { join as join8 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import chalk10 from "chalk";
 async function simulateCommand(prompt) {
   const projectRoot = process.cwd();
   console.log(chalk10.blue(`Simulating prompt: "${prompt}"
 `));
   console.log(chalk10.dim("Files Claude would load:\n"));
-  const globalClaude = join7(homedir5(), ".claude", "CLAUDE.md");
-  if (existsSync6(globalClaude)) {
+  const globalClaude = join8(homedir6(), ".claude", "CLAUDE.md");
+  if (existsSync7(globalClaude)) {
     console.log(chalk10.green("  \u2713 ~/.claude/CLAUDE.md (global)"));
   }
   for (const rootFile of ROOT_FILES) {
-    const fullPath = join7(projectRoot, rootFile);
-    if (existsSync6(fullPath)) {
+    const fullPath = join8(projectRoot, rootFile);
+    if (existsSync7(fullPath)) {
       console.log(chalk10.green(`  \u2713 ${rootFile} (project root)`));
     }
   }
   const settingsFiles = [
-    join7(homedir5(), ".claude", "settings.json"),
-    join7(homedir5(), ".claude", "settings.local.json"),
-    join7(projectRoot, ".claude", "settings.json"),
-    join7(projectRoot, ".claude", "settings.local.json")
+    join8(homedir6(), ".claude", "settings.json"),
+    join8(homedir6(), ".claude", "settings.local.json"),
+    join8(projectRoot, ".claude", "settings.json"),
+    join8(projectRoot, ".claude", "settings.local.json")
   ];
   for (const sf of settingsFiles) {
-    if (existsSync6(sf)) {
-      const display = sf.startsWith(homedir5()) ? sf.replace(homedir5(), "~") : sf.replace(projectRoot + "/", "");
+    if (existsSync7(sf)) {
+      const display = sf.startsWith(homedir6()) ? sf.replace(homedir6(), "~") : sf.replace(projectRoot + "/", "");
       console.log(chalk10.green(`  \u2713 ${display} (settings)`));
     }
   }
   const words = prompt.split(/\s+/);
   for (const word of words) {
     const cleaned = word.replace(/['"]/g, "");
-    const candidatePath = join7(projectRoot, cleaned);
-    if (existsSync6(candidatePath) && cleaned.includes("/")) {
+    const candidatePath = join8(projectRoot, cleaned);
+    if (existsSync7(candidatePath) && cleaned.includes("/")) {
       console.log(chalk10.cyan(`  \u2192 ${cleaned} (referenced in prompt)`));
     }
   }
@@ -1107,18 +1378,18 @@ async function simulateCommand(prompt) {
 }
 
 // dist/commands/print.js
-import { join as join8 } from "node:path";
-import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
-import { existsSync as existsSync7 } from "node:fs";
+import { join as join9 } from "node:path";
+import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync8 } from "node:fs";
 import chalk11 from "chalk";
 async function printCommand(title) {
   const projectRoot = process.cwd();
-  const scanDataPath = join8(projectRoot, "output", "index.html");
-  if (!existsSync7(scanDataPath)) {
+  const scanDataPath = join9(projectRoot, "output", "index.html");
+  if (!existsSync8(scanDataPath)) {
     console.error(chalk11.red("No scan data found. Run: md4ai scan"));
     process.exit(1);
   }
-  const html = await readFile4(scanDataPath, "utf-8");
+  const html = await readFile5(scanDataPath, "utf-8");
   const match = html.match(/<script type="application\/json" id="scan-data">([\s\S]*?)<\/script>/);
   if (!match) {
     console.error(chalk11.red("Could not extract scan data from output/index.html"));
@@ -1126,7 +1397,7 @@ async function printCommand(title) {
   }
   const result = JSON.parse(match[1]);
   const printHtml = generatePrintHtml(result, title);
-  const outputPath = join8(projectRoot, "output", `print-${Date.now()}.html`);
+  const outputPath = join9(projectRoot, "output", `print-${Date.now()}.html`);
   await writeFile3(outputPath, printHtml, "utf-8");
   console.log(chalk11.green(`Print-ready wall sheet: ${outputPath}`));
 }
@@ -1210,6 +1481,7 @@ async function syncCommand(options) {
           last_scanned: result.scannedAt,
           data_hash: result.dataHash
         }).eq("id", device.folder_id);
+        await pushToolings(supabase, device.folder_id, result.toolings);
         await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
         console.log(chalk12.green(`  Done: ${device.device_name}`));
       } catch (err) {
@@ -1243,6 +1515,7 @@ async function syncCommand(options) {
       last_scanned: result.scannedAt,
       data_hash: result.dataHash
     }).eq("id", device.folder_id);
+    await pushToolings(supabase, device.folder_id, result.toolings);
     await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
     await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
     console.log(chalk12.green("Synced."));
@@ -1315,6 +1588,7 @@ Linking "${folder.name}" to this device...
   console.log(`  References:${result.graph.edges.length}`);
   console.log(`  Orphans:   ${result.orphans.length}`);
   console.log(`  Skills:    ${result.skills.length}`);
+  console.log(`  Toolings:  ${result.toolings.length}`);
   const { error: scanErr } = await supabase.from("claude_folders").update({
     graph_json: result.graph,
     orphans_json: result.orphans,
@@ -1326,6 +1600,7 @@ Linking "${folder.name}" to this device...
   if (scanErr) {
     console.error(chalk13.yellow(`Scan upload warning: ${scanErr.message}`));
   }
+  await pushToolings(supabase, folder.id, result.toolings);
   const configFiles = await readClaudeConfigFiles(cwd);
   if (configFiles.length > 0) {
     for (const file of configFiles) {
@@ -1354,18 +1629,18 @@ Linking "${folder.name}" to this device...
 }
 
 // dist/commands/import-bundle.js
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
-import { join as join9, dirname as dirname2 } from "node:path";
-import { existsSync as existsSync8 } from "node:fs";
+import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
+import { join as join10, dirname as dirname2 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
 import chalk14 from "chalk";
 import { confirm, input as input4 } from "@inquirer/prompts";
 async function importBundleCommand(zipPath) {
-  if (!existsSync8(zipPath)) {
+  if (!existsSync9(zipPath)) {
     console.error(chalk14.red(`File not found: ${zipPath}`));
     process.exit(1);
   }
   const JSZip = (await import("jszip")).default;
-  const zipData = await readFile5(zipPath);
+  const zipData = await readFile6(zipPath);
   const zip = await JSZip.loadAsync(zipData);
   const manifestFile = zip.file("manifest.json");
   if (!manifestFile) {
@@ -1407,9 +1682,9 @@ Files to extract:`));
     return;
   }
   for (const file of files) {
-    const fullPath = join9(targetDir, file.filePath);
+    const fullPath = join10(targetDir, file.filePath);
     const dir = dirname2(fullPath);
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       await mkdir3(dir, { recursive: true });
     }
     await writeFile4(fullPath, file.content, "utf-8");
@@ -1419,6 +1694,294 @@ Files to extract:`));
 Done! ${files.length} file(s) extracted to ${targetDir}`));
 }
 
+// dist/commands/admin-update-tool.js
+import chalk15 from "chalk";
+var VALID_CATEGORIES = ["framework", "runtime", "cli", "mcp", "package", "database", "other"];
+async function adminUpdateToolCommand(options) {
+  const { supabase } = await getAuthenticatedClient();
+  if (!options.name) {
+    console.error(chalk15.red("--name is required."));
+    process.exit(1);
+  }
+  if (options.category && !VALID_CATEGORIES.includes(options.category)) {
+    console.error(chalk15.red(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`));
+    process.exit(1);
+  }
+  const { data: existing } = await supabase.from("tools_registry").select("id, name, display_name, category").eq("name", options.name).maybeSingle();
+  if (existing) {
+    const updates = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    if (options.display)
+      updates.display_name = options.display;
+    if (options.category)
+      updates.category = options.category;
+    if (options.stable)
+      updates.latest_stable = options.stable;
+    if (options.beta)
+      updates.latest_beta = options.beta;
+    if (options.source)
+      updates.source_url = options.source;
+    if (options.install)
+      updates.install_url = options.install;
+    if (options.notes)
+      updates.notes = options.notes;
+    const { error } = await supabase.from("tools_registry").update(updates).eq("id", existing.id);
+    if (error) {
+      console.error(chalk15.red(`Failed to update: ${error.message}`));
+      process.exit(1);
+    }
+    console.log(chalk15.green(`Updated "${existing.display_name}" in the registry.`));
+  } else {
+    if (!options.display || !options.category) {
+      console.error(chalk15.red("New tools require --display and --category."));
+      process.exit(1);
+    }
+    const { error } = await supabase.from("tools_registry").insert({
+      name: options.name,
+      display_name: options.display,
+      category: options.category,
+      latest_stable: options.stable ?? null,
+      latest_beta: options.beta ?? null,
+      source_url: options.source ?? null,
+      install_url: options.install ?? null,
+      notes: options.notes ?? null
+    });
+    if (error) {
+      console.error(chalk15.red(`Failed to create: ${error.message}`));
+      process.exit(1);
+    }
+    console.log(chalk15.green(`Added "${options.display}" to the registry.`));
+  }
+}
+
+// dist/commands/admin-list-tools.js
+import chalk16 from "chalk";
+async function adminListToolsCommand() {
+  const { supabase } = await getAuthenticatedClient();
+  const { data: tools, error } = await supabase.from("tools_registry").select("*").order("category").order("display_name");
+  if (error) {
+    console.error(chalk16.red(`Failed to fetch tools: ${error.message}`));
+    process.exit(1);
+  }
+  if (!tools?.length) {
+    console.log(chalk16.yellow("No tools in the registry."));
+    return;
+  }
+  const nameW = Math.max(16, ...tools.map((t) => t.display_name.length));
+  const catW = Math.max(10, ...tools.map((t) => t.category.length));
+  const stableW = Math.max(8, ...tools.map((t) => (t.latest_stable ?? "\u2014").length));
+  const betaW = Math.max(8, ...tools.map((t) => (t.latest_beta ?? "\u2014").length));
+  const header = [
+    "Name".padEnd(nameW),
+    "Category".padEnd(catW),
+    "Stable".padEnd(stableW),
+    "Beta".padEnd(betaW),
+    "Last Checked"
+  ].join("  ");
+  console.log(chalk16.bold(header));
+  console.log("\u2500".repeat(header.length));
+  for (const tool of tools) {
+    const lastChecked = tool.updated_at ? formatRelative(new Date(tool.updated_at)) : "\u2014";
+    const row = [
+      tool.display_name.padEnd(nameW),
+      tool.category.padEnd(catW),
+      (tool.latest_stable ?? "\u2014").padEnd(stableW),
+      (tool.latest_beta ?? "\u2014").padEnd(betaW),
+      lastChecked
+    ].join("  ");
+    console.log(row);
+  }
+  console.log(chalk16.grey(`
+${tools.length} tool(s) in registry.`));
+}
+function formatRelative(date) {
+  const diff = Date.now() - date.getTime();
+  const hours = Math.floor(diff / (1e3 * 60 * 60));
+  if (hours < 1)
+    return "just now";
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7)
+    return `${days}d ago`;
+  return date.toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric" });
+}
+
+// dist/commands/admin-fetch-versions.js
+import chalk17 from "chalk";
+
+// dist/commands/version-sources.js
+var VERSION_SOURCES = {
+  "next": { type: "npm", package: "next" },
+  "react": { type: "npm", package: "react" },
+  "react-dom": { type: "npm", package: "react-dom" },
+  "typescript": { type: "npm", package: "typescript" },
+  "tailwindcss": { type: "npm", package: "tailwindcss" },
+  "esbuild": { type: "npm", package: "esbuild" },
+  "chalk": { type: "npm", package: "chalk" },
+  "commander": { type: "npm", package: "commander" },
+  "inquirer": { type: "npm", package: "inquirer" },
+  "playwright": { type: "npm", package: "playwright" },
+  "resend": { type: "npm", package: "resend" },
+  "@supabase/supabase-js": { type: "npm", package: "@supabase/supabase-js" },
+  "pnpm": { type: "npm", package: "pnpm" },
+  "claude-code": { type: "npm", package: "@anthropic-ai/claude-code" },
+  "turborepo": { type: "npm", package: "turbo" },
+  "npm": { type: "npm", package: "npm" },
+  "node": { type: "github", repo: "nodejs/node" },
+  "supabase-cli": { type: "github", repo: "supabase/cli" }
+};
+
+// dist/commands/admin-fetch-versions.js
+async function adminFetchVersionsCommand() {
+  const { supabase } = await getAuthenticatedClient();
+  const { data: tools, error } = await supabase.from("tools_registry").select("*").order("display_name");
+  if (error) {
+    console.error(chalk17.red(`Failed to fetch tools: ${error.message}`));
+    process.exit(1);
+  }
+  if (!tools?.length) {
+    console.log(chalk17.yellow("No tools in the registry."));
+  }
+  const { data: allProjectToolings } = await supabase.from("project_toolings").select("tool_name, detection_source").is("tool_id", null);
+  const registeredNames = new Set((tools ?? []).map((t) => t.name));
+  const unregisteredNames = /* @__PURE__ */ new Set();
+  for (const pt of allProjectToolings ?? []) {
+    if (!registeredNames.has(pt.tool_name) && pt.detection_source === "package.json") {
+      unregisteredNames.add(pt.tool_name);
+    }
+  }
+  if (unregisteredNames.size > 0) {
+    console.log(chalk17.blue(`Auto-registering ${unregisteredNames.size} unverified package(s)...
+`));
+    for (const name of unregisteredNames) {
+      const displayName = name;
+      const { data: inserted, error: insertError } = await supabase.from("tools_registry").upsert({
+        name,
+        display_name: displayName,
+        category: "package",
+        source_url: `https://www.npmjs.com/package/${name}`,
+        install_url: `https://www.npmjs.com/package/${name}`
+      }, { onConflict: "name" }).select().single();
+      if (!insertError && inserted) {
+        tools.push(inserted);
+        await supabase.from("project_toolings").update({ tool_id: inserted.id }).eq("tool_name", name).is("tool_id", null);
+      }
+    }
+  }
+  if (!tools?.length) {
+    console.log(chalk17.yellow("No tools to fetch."));
+    return;
+  }
+  console.log(chalk17.bold(`Fetching versions for ${tools.length} tool(s)...
+`));
+  const results = await Promise.all(tools.map(async (tool) => {
+    const source = VERSION_SOURCES[tool.name] ?? { type: "npm", package: tool.name };
+    try {
+      const { stable, beta } = await fetchVersions(source);
+      const stableChanged = stable !== tool.latest_stable;
+      const betaChanged = beta !== tool.latest_beta;
+      const updates = {
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (stableChanged)
+        updates.latest_stable = stable;
+      if (betaChanged)
+        updates.latest_beta = beta;
+      const { error: updateError } = await supabase.from("tools_registry").update(updates).eq("id", tool.id);
+      if (updateError) {
+        return { displayName: tool.display_name, stable, beta, status: "failed" };
+      }
+      return {
+        displayName: tool.display_name,
+        stable,
+        beta,
+        status: stableChanged || betaChanged ? "updated" : "unchanged"
+      };
+    } catch {
+      return { displayName: tool.display_name, stable: null, beta: null, status: "failed" };
+    }
+  }));
+  const nameW = Math.max(16, ...results.map((r) => r.displayName.length));
+  const stableW = Math.max(8, ...results.map((r) => (r.stable ?? "\u2014").length));
+  const betaW = Math.max(8, ...results.map((r) => (r.beta ?? "\u2014").length));
+  const statusW = 10;
+  const header = [
+    "Tool".padEnd(nameW),
+    "Stable".padEnd(stableW),
+    "Beta".padEnd(betaW),
+    "Status".padEnd(statusW)
+  ].join("  ");
+  console.log(chalk17.bold(header));
+  console.log("\u2500".repeat(header.length));
+  for (const result of results) {
+    const statusColour = result.status === "updated" ? chalk17.green : result.status === "unchanged" ? chalk17.grey : result.status === "failed" ? chalk17.red : chalk17.yellow;
+    const row = [
+      result.displayName.padEnd(nameW),
+      (result.stable ?? "\u2014").padEnd(stableW),
+      (result.beta ?? "\u2014").padEnd(betaW),
+      statusColour(result.status.padEnd(statusW))
+    ].join("  ");
+    console.log(row);
+  }
+  const updated = results.filter((r) => r.status === "updated").length;
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  const failed = results.filter((r) => r.status === "failed").length;
+  const noSource = results.filter((r) => r.status === "no source").length;
+  console.log(chalk17.grey(`
+${results.length} tool(s): `) + chalk17.green(`${updated} updated`) + ", " + chalk17.grey(`${unchanged} unchanged`) + ", " + chalk17.red(`${failed} failed`) + ", " + chalk17.yellow(`${noSource} no source`));
+}
+async function fetchVersions(source) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e3);
+  try {
+    if (source.type === "npm") {
+      return await fetchNpmVersions(source.package, controller.signal);
+    } else {
+      return await fetchGitHubVersions(source.repo, controller.signal);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchNpmVersions(packageName, signal) {
+  const url = `https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`;
+  const res = await fetch(url, { signal });
+  if (!res.ok) {
+    throw new Error(`npm registry returned ${res.status}`);
+  }
+  const tags = await res.json();
+  const stable = tags.latest ?? null;
+  const beta = tags.next ?? tags.beta ?? tags.rc ?? null;
+  return { stable, beta };
+}
+async function fetchGitHubVersions(repo, signal) {
+  const url = `https://api.github.com/repos/${repo}/releases?per_page=20`;
+  const res = await fetch(url, {
+    signal,
+    headers: { Accept: "application/vnd.github+json" }
+  });
+  if (!res.ok) {
+    throw new Error(`GitHub API returned ${res.status}`);
+  }
+  const releases = await res.json();
+  let stable = null;
+  let beta = null;
+  for (const release of releases) {
+    if (release.draft)
+      continue;
+    const version = release.tag_name.replace(/^v/, "");
+    if (!release.prerelease && !stable) {
+      stable = version;
+    }
+    if (release.prerelease && !beta) {
+      beta = version;
+    }
+    if (stable && beta)
+      break;
+  }
+  return { stable, beta };
+}
+
 // dist/index.js
 var program = new Command();
 program.name("md4ai").description("MD4AI \u2014 Claude tooling visualiser").version(CURRENT_VERSION).addHelpText("after", `
@@ -1440,4 +2003,8 @@ program.command("print <title>").description("Generate a printable wall-chart HT
 program.command("sync").description("Re-push latest scan data to Supabase").option("--all", "Sync all folders on all devices").action(syncCommand);
 program.command("import <zipfile>").description("Import a Claude setup bundle exported from the web dashboard").action(importBundleCommand);
 program.command("check-update").description("Check if a newer version of md4ai is available").action(checkForUpdate);
+var admin = program.command("admin").description("Admin commands for managing the tools registry");
+admin.command("update-tool").description("Add or update a tool in the master registry").requiredOption("--name <name>", "Canonical tool name (e.g. next, playwright)").option("--display <display>", 'Human-friendly display name (e.g. "Next.js")').option("--category <category>", "Tool category (framework|runtime|cli|mcp|package|database|other)").option("--stable <version>", "Latest stable version").option("--beta <version>", "Latest beta/RC version").option("--source <url>", "Source of truth URL for checking versions").option("--install <url>", "Download/install link").option("--notes <text>", "Compatibility notes or warnings").action(adminUpdateToolCommand);
+admin.command("list-tools").description("List all tools in the master registry").action(adminListToolsCommand);
+admin.command("fetch-versions").description("Fetch latest stable and beta versions from npm and GitHub").action(adminFetchVersionsCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md4ai",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "CLI for MD4AI — scan Claude projects and sync to your dashboard",
   "type": "module",
   "bin": {