nairon-bench 0.5.0 → 0.5.2

package/dist/index.js

@@ -4447,8 +4447,8 @@ function defineCommand2(def) {
 
 // src/commands/scan.ts
 init_dist();
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync10 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -16068,6 +16068,251 @@ function filterAlreadyInstalled(optimizations, status) {
   });
 }
 
+// src/lib/first-run.ts
+init_dist();
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var FIRST_RUN_FLAG = join9(homedir8(), ".nairon-bench", "first-run-complete");
+var PROJECT_SCAN_MARKER = ".nairon/first-scan-complete";
+function isFirstScanInProject(projectDir) {
+  return !existsSync9(join9(projectDir, PROJECT_SCAN_MARKER));
+}
+function markProjectScanned(projectDir) {
+  const naironDir = join9(projectDir, ".nairon");
+  if (!existsSync9(naironDir)) {
+    mkdirSync4(naironDir, { recursive: true });
+  }
+  writeFileSync4(join9(projectDir, PROJECT_SCAN_MARKER), new Date().toISOString());
+}
+var AGENT_CONFIGS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    paths: [".claude"]
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    paths: [".config/opencode", ".local/share/opencode", ".opencode"]
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    paths: [".cursor"]
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    paths: [".codex"]
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    paths: [".github-copilot"]
+  },
+  {
+    id: "cody",
+    name: "Sourcegraph Cody",
+    paths: [".cody"]
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    paths: [".aider"]
+  }
+];
+function detectAllAgents() {
+  const home = homedir8();
+  const cwd = process.cwd();
+  const detected = [];
+  for (const agent of AGENT_CONFIGS) {
+    for (const relativePath of agent.paths) {
+      const homePath = join9(home, relativePath);
+      if (existsSync9(homePath)) {
+        detected.push({ id: agent.id, name: agent.name, configPath: homePath });
+        break;
+      }
+      const projectPath = join9(cwd, relativePath);
+      if (existsSync9(projectPath)) {
+        detected.push({ id: agent.id, name: agent.name, configPath: projectPath });
+        break;
+      }
+    }
+  }
+  return detected;
+}
+function analyzeReadme(projectDir) {
+  const readmePath = join9(projectDir, "README.md");
+  if (!existsSync9(readmePath)) {
+    const alternatives = ["readme.md", "Readme.md", "README.MD", "README"];
+    for (const alt of alternatives) {
+      const altPath = join9(projectDir, alt);
+      if (existsSync9(altPath)) {
+        return parseReadme(readFileSync9(altPath, "utf-8"), projectDir);
+      }
+    }
+    return null;
+  }
+  const content = readFileSync9(readmePath, "utf-8");
+  return parseReadme(content, projectDir);
+}
+function parseReadme(content, projectDir) {
+  let name = "Unknown Project";
+  const pkgPath = join9(projectDir, "package.json");
+  if (existsSync9(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+      if (pkg.name && !pkg.name.startsWith("@") && pkg.name !== "root") {
+        name = pkg.name;
+      }
+    } catch {}
+  }
+  if (name === "Unknown Project") {
+    const headingMatch = content.match(/^#\s+([^<\n]+)$/m);
+    if (headingMatch && headingMatch[1]) {
+      const heading = headingMatch[1].trim();
+      if (!heading.toLowerCase().includes("install") && !heading.toLowerCase().includes("getting started") && heading.length < 50) {
+        name = heading;
+      }
+    }
+  }
+  let description = "";
+  const descMatch = content.match(/^#[^#].*\n\n(.+?)(\n\n|$)/s);
+  if (descMatch && descMatch[1]) {
+    description = descMatch[1].replace(/\n/g, " ").trim().slice(0, 200);
+  }
+  const techStack = [];
+  const techPatterns = {
+    react: /\breact\b/i,
+    "next.js": /\bnext\.?js\b/i,
+    vue: /\bvue\b/i,
+    svelte: /\bsvelte\b/i,
+    typescript: /\btypescript\b/i,
+    python: /\bpython\b/i,
+    rust: /\brust\b/i,
+    go: /\bgolang?\b/i,
+    node: /\bnode\.?js\b/i,
+    bun: /\bbun\b/i,
+    deno: /\bdeno\b/i,
+    tailwind: /\btailwind\b/i,
+    prisma: /\bprisma\b/i,
+    postgres: /\bpostgres\b/i,
+    mongodb: /\bmongo\b/i,
+    redis: /\bredis\b/i,
+    docker: /\bdocker\b/i,
+    kubernetes: /\bkubernetes\b|\bk8s\b/i,
+    aws: /\baws\b/i,
+    vercel: /\bvercel\b/i,
+    cloudflare: /\bcloudflare\b/i,
+    openai: /\bopenai\b/i,
+    anthropic: /\banthropic\b|\bclaude\b/i,
+    langchain: /\blangchain\b/i,
+    convex: /\bconvex\b/i,
+    supabase: /\bsupabase\b/i,
+    firebase: /\bfirebase\b/i,
+    stripe: /\bstripe\b/i,
+    playwright: /\bplaywright\b/i,
+    vitest: /\bvitest\b/i,
+    jest: /\bjest\b/i,
+    remotion: /\bremotion\b/i
+  };
+  for (const [tech, pattern] of Object.entries(techPatterns)) {
+    if (pattern.test(content)) {
+      techStack.push(tech);
+    }
+  }
+  const keywords = [];
+  const keywordPatterns = {
+    api: /\bapi\b|\brest\b|\bgraphql\b/i,
+    cli: /\bcli\b|\bcommand.?line\b/i,
+    web: /\bweb\b|\bwebsite\b|\bfrontend\b/i,
+    mobile: /\bmobile\b|\bios\b|\bandroid\b|\breact.?native\b/i,
+    ai: /\bai\b|\bmachine.?learning\b|\bllm\b|\bgpt\b/i,
+    video: /\bvideo\b|\bstreaming\b|\bmedia\b/i,
+    ecommerce: /\becommerce\b|\bshop\b|\bstore\b|\bpayment\b/i,
+    auth: /\bauth\b|\blogin\b|\bsession\b/i,
+    testing: /\btest\b|\btesting\b|\btdd\b/i,
+    devtools: /\bdevtool\b|\bdeveloper.?tool\b/i
+  };
+  for (const [keyword, pattern] of Object.entries(keywordPatterns)) {
+    if (pattern.test(content)) {
+      keywords.push(keyword);
+    }
+  }
+  return { name, description, techStack, keywords };
+}
+function suggestSkills(context) {
+  const suggestions = [];
+  suggestions.push({
+    name: "Find Skills",
+    installCommand: "npx skills add vercel-labs/skills@find-skills --yes",
+    reason: "Discover more skills for your workflow"
+  });
+  if (!context) {
+    suggestions.push({
+      name: "Writing Plans",
+      installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+      reason: "Better planning before implementation"
+    });
+    return suggestions;
+  }
+  if (context.techStack.includes("react") || context.techStack.includes("next.js")) {
+    suggestions.push({
+      name: "React Best Practices",
+      installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes",
+      reason: `Detected React/Next.js in ${context.name}`
+    });
+  }
+  if (context.techStack.includes("remotion")) {
+    suggestions.push({
+      name: "Remotion",
+      installCommand: "npx skills add remotion-dev/skills@remotion-best-practices --yes",
+      reason: "Detected Remotion video framework"
+    });
+  }
+  if (context.keywords.includes("testing") || context.keywords.includes("tdd")) {
+    suggestions.push({
+      name: "Test-Driven Development",
+      installCommand: "npx skills add obra/superpowers@test-driven-development --yes",
+      reason: "Testing focus detected"
+    });
+  }
+  if (context.keywords.includes("web")) {
+    suggestions.push({
+      name: "Web Design Guidelines",
+      installCommand: "npx skills add vercel-labs/agent-skills@web-design-guidelines --yes",
+      reason: "Web project detected"
+    });
+  }
+  if (!suggestions.some((s2) => s2.name.includes("Plan"))) {
+    suggestions.push({
+      name: "Writing Plans",
+      installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+      reason: "Helps structure work before coding"
+    });
+  }
+  return suggestions.slice(0, 5);
+}
+function installSkill2(installCommand) {
+  try {
+    const result = spawnSync2("npx", installCommand.replace("npx ", "").split(" "), {
+      stdio: "pipe",
+      timeout: 60000,
+      shell: true
+    });
+    if (result.status === 0) {
+      return { success: true, message: "Installed successfully" };
+    } else {
+      const stderr = result.stderr?.toString() || "";
+      return { success: false, message: stderr.slice(0, 100) || "Installation failed" };
+    }
+  } catch (error2) {
+    return { success: false, message: error2 instanceof Error ? error2.message : "Unknown error" };
+  }
+}
+
 // src/commands/scan.ts
 var scanCommand = defineCommand2({
   meta: {
@@ -16109,6 +16354,10 @@ var scanCommand = defineCommand2({
         ]
       });
       since = parseSince(period);
+      if (isFirstScanInProject(projectDir)) {
+        await showFirstScanWelcome(projectDir);
+        markProjectScanned(projectDir);
+      }
     }
     const useCache = true;
     const watchMode = false;
@@ -16245,7 +16494,7 @@ var scanCommand = defineCommand2({
       console.log(`     Projected monthly: ${colors2.primary(`$${scanCost.projectedMonthlyCostUsd.toFixed(2)}`)}`);
       console.log(colors2.dim("  " + "═".repeat(45)));
       console.log();
-      const reportDir = join9(projectDir, ".nairon/reports");
+      const reportDir = join10(projectDir, ".nairon/reports");
       const reportPath = generateReport(reportDir, score, git, agents, tests, "7d", sdlcAnalysis, scanCost, analysis);
       console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
       if (agents && agents.sessions.length > 0) {
@@ -16461,12 +16710,12 @@ var scanCommand = defineCommand2({
   }
 });
 function loadProjectContext(projectDir) {
-  const contextPath = join9(projectDir, ".nairon", "context.json");
-  if (!existsSync9(contextPath)) {
+  const contextPath = join10(projectDir, ".nairon", "context.json");
+  if (!existsSync10(contextPath)) {
     return null;
   }
   try {
-    const raw = readFileSync9(contextPath, "utf-8");
+    const raw = readFileSync10(contextPath, "utf-8");
     const data = JSON.parse(raw);
     const context = {
       painPoints: data.painPoints || [],
@@ -16519,12 +16768,12 @@ function parseSince(since) {
   return new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
 }
 function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysis, scanCost, analysis) {
-  if (!existsSync9(reportDir)) {
-    mkdirSync4(reportDir, { recursive: true });
+  if (!existsSync10(reportDir)) {
+    mkdirSync5(reportDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = `scan-${timestamp}.md`;
-  const filepath = join9(reportDir, filename);
+  const filepath = join10(reportDir, filename);
   const lines = [];
   lines.push(`# NaironAI Scan Report`);
   lines.push("");
@@ -16640,7 +16889,7 @@ function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysi
   lines.push("---");
   lines.push("");
   lines.push("*Generated by [nairon-bench](https://github.com/ObaidUr-Rahmaan/nairon-bench)*");
-  writeFileSync4(filepath, lines.join(`
+  writeFileSync5(filepath, lines.join(`
 `));
   return filepath;
 }
@@ -16659,15 +16908,87 @@ function formatTokensPlain(tokens) {
     return `${Math.round(tokens / 1000)}K`;
   return tokens.toString();
 }
+async function showFirstScanWelcome(projectDir) {
+  console.log();
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log(`  ${colors2.primary("✨")} ${colors2.bold("First scan in this project!")}`);
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log();
+  const detectedAgents = detectAllAgents();
+  let selectedAgent = null;
+  if (detectedAgents.length === 0) {
+    console.log(`  ${icons.info} No AI coding agents detected`);
+    console.log(`  ${colors2.dim("  Install Claude Code, Cursor, or OpenCode to get started")}`);
+  } else if (detectedAgents.length === 1) {
+    selectedAgent = detectedAgents[0];
+    console.log(`  ${icons.info} Detected agent: ${colors2.bold(selectedAgent.name)}`);
+  } else {
+    console.log(`  ${icons.info} Found ${colors2.bold(detectedAgents.length.toString())} AI coding agents:`);
+    console.log();
+    const agentChoice = await consola.prompt("Which agent are you using for this project?", {
+      type: "select",
+      options: detectedAgents.map((a2) => ({
+        value: a2.id,
+        label: a2.name
+      }))
+    });
+    selectedAgent = detectedAgents.find((a2) => a2.id === agentChoice) || detectedAgents[0];
+    console.log();
+    console.log(`  ${icons.success} Selected: ${colors2.bold(selectedAgent.name)}`);
+  }
+  const context = analyzeReadme(projectDir);
+  if (context) {
+    console.log(`  ${icons.info} Project: ${colors2.bold(context.name)}`);
+    if (context.techStack.length > 0) {
+      console.log(`  ${colors2.dim("  Tech: " + context.techStack.slice(0, 4).join(", "))}`);
+    }
+  }
+  console.log();
+  const suggestions = suggestSkills(context);
+  if (suggestions.length > 0) {
+    console.log(`  ${colors2.bold("Recommended skills for this project:")}`);
+    console.log();
+    for (let i3 = 0;i3 < Math.min(3, suggestions.length); i3++) {
+      const s2 = suggestions[i3];
+      console.log(`  ${colors2.primary((i3 + 1).toString())}. ${colors2.bold(s2.name)}`);
+      console.log(`     ${colors2.dim(s2.reason)}`);
+    }
+    console.log();
+    const installChoice = await consola.prompt("Install recommended skills?", {
+      type: "select",
+      options: [
+        { value: "find-skills", label: "Just find-skills (discover more skills later)" },
+        { value: "all", label: "All recommended skills" },
+        { value: "skip", label: "Skip - continue to scan" }
+      ]
+    });
+    if (installChoice === "find-skills" || installChoice === "all") {
+      console.log();
+      const toInstall = installChoice === "all" ? suggestions.slice(0, 3) : suggestions.slice(0, 1);
+      for (const skill of toInstall) {
+        process.stdout.write(`  Installing ${skill.name}...`);
+        const result = installSkill2(skill.installCommand);
+        if (result.success) {
+          console.log(` ${colors2.success("✓")}`);
+        } else {
+          console.log(` ${colors2.warning("⚠")} ${colors2.dim(`(${result.message.slice(0, 50)})`)}`);
+        }
+      }
+      console.log();
+    }
+  }
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log();
+}
 
 // src/commands/report.ts
 init_dist();
 init_client();
 
 // src/collectors/report-data.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10, basename as basename3 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join11, basename as basename3 } from "node:path";
 async function collectReportData(projectDir, since, until = new Date, harness) {
   const projectName = basename3(projectDir);
   const [commits, allSessions, mcpConfigs] = await Promise.all([
@@ -16750,12 +17071,12 @@ function detectAIAssistedCommit(message) {
 }
 async function collectAllSessions(since, until, projectDir) {
   const sessions = [];
-  const claudeDir = join10(homedir8(), ".claude");
-  if (existsSync10(claudeDir)) {
+  const claudeDir = join11(homedir9(), ".claude");
+  if (existsSync11(claudeDir)) {
     sessions.push(...collectClaudeCodeSessions(claudeDir, since, until, projectDir));
   }
-  const openCodeDir = join10(homedir8(), ".local", "share", "opencode");
-  if (existsSync10(openCodeDir)) {
+  const openCodeDir = join11(homedir9(), ".local", "share", "opencode");
+  if (existsSync11(openCodeDir)) {
     sessions.push(...collectOpenCodeSessions2(openCodeDir, since, until));
   }
   sessions.sort((a2, b2) => a2.startTime.getTime() - b2.startTime.getTime());
@@ -16763,15 +17084,15 @@ async function collectAllSessions(since, until, projectDir) {
 }
 function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   const sessions = [];
-  const transcriptsDir = join10(claudeDir, "transcripts");
-  if (!existsSync10(transcriptsDir))
+  const transcriptsDir = join11(claudeDir, "transcripts");
+  if (!existsSync11(transcriptsDir))
     return sessions;
   const projectHash = projectDir ? hashPath(projectDir) : null;
-  const projectsDir = join10(claudeDir, "projects");
+  const projectsDir = join11(claudeDir, "projects");
   try {
     const transcriptFiles = readdirSync5(transcriptsDir).filter((f3) => f3.endsWith(".jsonl"));
     for (const file of transcriptFiles) {
-      const filePath = join10(transcriptsDir, file);
+      const filePath = join11(transcriptsDir, file);
       const stat = statSync2(filePath);
       if (stat.mtime < since || stat.mtime > until)
         continue;
@@ -16782,12 +17103,12 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
         }
       } catch {}
     }
-    if (projectHash && existsSync10(projectsDir)) {
-      const projectSessionDir = join10(projectsDir, projectHash);
-      if (existsSync10(projectSessionDir)) {
+    if (projectHash && existsSync11(projectsDir)) {
+      const projectSessionDir = join11(projectsDir, projectHash);
+      if (existsSync11(projectSessionDir)) {
         const projectFiles = readdirSync5(projectSessionDir).filter((f3) => f3.endsWith(".jsonl"));
         for (const file of projectFiles) {
-          const filePath = join10(projectSessionDir, file);
+          const filePath = join11(projectSessionDir, file);
           const stat = statSync2(filePath);
           if (stat.mtime < since || stat.mtime > until)
             continue;
@@ -16806,7 +17127,7 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   return sessions;
 }
 function parseClaudeTranscript(filePath, fileName) {
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const lines = content.trim().split(`
 `).filter((l2) => l2.trim());
   if (lines.length === 0)
@@ -16896,25 +17217,25 @@ function parseClaudeTranscript(filePath, fileName) {
 }
 function collectOpenCodeSessions2(openCodeDir, since, until) {
   const sessions = [];
-  const sessionDir = join10(openCodeDir, "storage", "session");
-  const messageDir = join10(openCodeDir, "storage", "message");
-  const partDir = join10(openCodeDir, "storage", "part");
-  if (!existsSync10(sessionDir))
+  const sessionDir = join11(openCodeDir, "storage", "session");
+  const messageDir = join11(openCodeDir, "storage", "message");
+  const partDir = join11(openCodeDir, "storage", "part");
+  if (!existsSync11(sessionDir))
     return sessions;
   try {
-    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join10(sessionDir, d2.name));
+    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join11(sessionDir, d2.name));
     for (const projectDir of projectDirs) {
       const sessionFiles = readdirSync5(projectDir).filter((f3) => f3.endsWith(".json"));
       for (const sessionFile of sessionFiles) {
         try {
-          const sessionPath = join10(projectDir, sessionFile);
-          const sessionData = JSON.parse(readFileSync10(sessionPath, "utf-8"));
+          const sessionPath = join11(projectDir, sessionFile);
+          const sessionData = JSON.parse(readFileSync11(sessionPath, "utf-8"));
           const createdAt = new Date(sessionData.time?.created || 0);
           const updatedAt = new Date(sessionData.time?.updated || sessionData.time?.created || 0);
           if (updatedAt < since || createdAt > until)
             continue;
           const sessionId = sessionData.id;
-          const sessionMsgDir = join10(messageDir, sessionId);
+          const sessionMsgDir = join11(messageDir, sessionId);
           const prompts = [];
           const responses = [];
           const toolsUsed = new Set;
@@ -16925,12 +17246,12 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
           let model = "unknown";
           let startTime = createdAt;
           let endTime = updatedAt;
-          if (existsSync10(sessionMsgDir)) {
+          if (existsSync11(sessionMsgDir)) {
             const msgFiles = readdirSync5(sessionMsgDir).filter((f3) => f3.endsWith(".json")).sort();
             for (const msgFile of msgFiles) {
               try {
-                const msgPath = join10(sessionMsgDir, msgFile);
-                const msgData = JSON.parse(readFileSync10(msgPath, "utf-8"));
+                const msgPath = join11(sessionMsgDir, msgFile);
+                const msgData = JSON.parse(readFileSync11(msgPath, "utf-8"));
                 const msgId = msgData.id;
                 if (msgData.model?.modelID) {
                   model = msgData.model.modelID;
@@ -16940,14 +17261,14 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
                   startTime = msgTime;
                 if (msgTime > endTime)
                   endTime = msgTime;
-                const msgPartDir = join10(partDir, msgId);
+                const msgPartDir = join11(partDir, msgId);
                 let messageText = "";
-                if (existsSync10(msgPartDir)) {
+                if (existsSync11(msgPartDir)) {
                   const partFiles = readdirSync5(msgPartDir).filter((f3) => f3.endsWith(".json")).sort();
                   for (const partFile of partFiles) {
                     try {
-                      const partPath = join10(msgPartDir, partFile);
-                      const partData = JSON.parse(readFileSync10(partPath, "utf-8"));
+                      const partPath = join11(msgPartDir, partFile);
+                      const partData = JSON.parse(readFileSync11(partPath, "utf-8"));
                       if (partData.type === "text" && partData.text && !partData.synthetic) {
                         messageText += partData.text + `
 `;
@@ -17121,10 +17442,10 @@ function analyzeResponse(text, sessionId, index, promptId, timestamp) {
 }
 function collectMCPConfigs() {
   const configs = [];
-  const claudeConfig = join10(homedir8(), ".claude.json");
-  if (existsSync10(claudeConfig)) {
+  const claudeConfig = join11(homedir9(), ".claude.json");
+  if (existsSync11(claudeConfig)) {
     try {
-      const data = JSON.parse(readFileSync10(claudeConfig, "utf-8"));
+      const data = JSON.parse(readFileSync11(claudeConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         configs.push({
@@ -17137,13 +17458,13 @@ function collectMCPConfigs() {
     } catch {}
   }
   const openCodeConfigs = [
-    join10(homedir8(), ".opencode.json"),
-    join10(homedir8(), ".config", "opencode", "opencode.json")
+    join11(homedir9(), ".opencode.json"),
+    join11(homedir9(), ".config", "opencode", "opencode.json")
   ];
   for (const configPath of openCodeConfigs) {
-    if (existsSync10(configPath)) {
+    if (existsSync11(configPath)) {
       try {
-        const data = JSON.parse(readFileSync10(configPath, "utf-8"));
+        const data = JSON.parse(readFileSync11(configPath, "utf-8"));
         const mcpServers = data.mcp || {};
         for (const [name, config] of Object.entries(mcpServers)) {
           if (!configs.find((c3) => c3.name === name)) {
@@ -17158,10 +17479,10 @@ function collectMCPConfigs() {
       } catch {}
     }
   }
-  const cursorConfig = join10(homedir8(), ".cursor", "mcp.json");
-  if (existsSync10(cursorConfig)) {
+  const cursorConfig = join11(homedir9(), ".cursor", "mcp.json");
+  if (existsSync11(cursorConfig)) {
     try {
-      const data = JSON.parse(readFileSync10(cursorConfig, "utf-8"));
+      const data = JSON.parse(readFileSync11(cursorConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         if (!configs.find((c3) => c3.name === name)) {
@@ -19362,9 +19683,9 @@ function getSeverityEmoji(severity) {
 }
 
 // src/lib/tool-analyzer.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync6 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join12 } from "node:path";
 function analyzeToolUtilization(data) {
   const mcpServers = analyzeMCPServers(data);
   const mcpSummary = buildMCPSummary(mcpServers);
@@ -19514,24 +19835,24 @@ function categorizeTools(tools) {
 }
 function analyzeSkills() {
   const skills = [];
-  const home = homedir9();
+  const home = homedir10();
   const skillsDirs = [
-    join11(home, ".claude", "skills"),
-    join11(home, ".agents", "skills"),
-    join11(home, ".config", "claude", "skills")
+    join12(home, ".claude", "skills"),
+    join12(home, ".agents", "skills"),
+    join12(home, ".config", "claude", "skills")
   ];
   const projectSkillsDirs = [
-    join11(process.cwd(), ".claude", "skills"),
-    join11(process.cwd(), ".agents", "skills")
+    join12(process.cwd(), ".claude", "skills"),
+    join12(process.cwd(), ".agents", "skills")
   ];
   const openCodeSkillDirs = [
-    join11(home, ".config", "opencode", "skills"),
-    join11(home, ".local", "share", "opencode", "skills")
+    join12(home, ".config", "opencode", "skills"),
+    join12(home, ".local", "share", "opencode", "skills")
   ];
   const allSkillDirs = [...skillsDirs, ...projectSkillsDirs, ...openCodeSkillDirs];
   const seenSkills = new Set;
   for (const skillsDir of allSkillDirs) {
-    if (existsSync11(skillsDir)) {
+    if (existsSync12(skillsDir)) {
       try {
         const entries = readdirSync6(skillsDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -19542,7 +19863,7 @@ function analyzeSkills() {
           if (entry.isDirectory() || entry.isSymbolicLink() || entry.name.endsWith(".md")) {
             skills.push({
               name: skillName,
-              path: join11(skillsDir, entry.name),
+              path: join12(skillsDir, entry.name),
               used: false,
               usageCount: 0
             });
@@ -19839,22 +20160,22 @@ function renderToolUtilizationMarkdown(analysis) {
 }
 
 // src/lib/coverage-parser.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
+import { join as join13 } from "node:path";
 function parseCoverageReport(projectDir) {
   const coveragePaths = [
-    { path: join12(projectDir, "coverage", "lcov.info"), parser: parseLcov },
-    { path: join12(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
-    { path: join12(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
-    { path: join12(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
-    { path: join12(projectDir, "coverage", "clover.xml"), parser: parseClover },
-    { path: join12(projectDir, "lcov.info"), parser: parseLcov },
-    { path: join12(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
+    { path: join13(projectDir, "coverage", "lcov.info"), parser: parseLcov },
+    { path: join13(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
+    { path: join13(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
+    { path: join13(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
+    { path: join13(projectDir, "coverage", "clover.xml"), parser: parseClover },
+    { path: join13(projectDir, "lcov.info"), parser: parseLcov },
+    { path: join13(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
   ];
   for (const { path, parser: parser4 } of coveragePaths) {
-    if (existsSync12(path)) {
+    if (existsSync13(path)) {
       try {
-        const content = readFileSync12(path, "utf-8");
+        const content = readFileSync13(path, "utf-8");
         return parser4(content, path);
       } catch {}
     }
@@ -21566,7 +21887,7 @@ function formatReportAsJSON(report) {
 }
 
 // src/commands/report.ts
-import { writeFileSync as writeFileSync5 } from "node:fs";
+import { writeFileSync as writeFileSync6 } from "node:fs";
 import { resolve } from "node:path";
 var reportCommand = defineCommand2({
   meta: {
@@ -21778,7 +22099,7 @@ async function runHackathonReport(args) {
     }
     if (args.output) {
       const filepath = resolve(projectDir, args.output);
-      writeFileSync5(filepath, output);
+      writeFileSync6(filepath, output);
       consola.success(`Report saved to ${filepath}`);
     }
     console.log(output);
@@ -21947,7 +22268,7 @@ async function runLeadershipReport(args) {
   }
   if (args.output) {
     const filepath = resolve(projectDir, args.output);
-    writeFileSync5(filepath, output);
+    writeFileSync6(filepath, output);
     consola.success(`Report saved to ${filepath}`);
   }
   console.log(output);
@@ -22109,9 +22430,9 @@ function renderBar4(value, width) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
 init_client();
 
 // src/lib/recommendations-db.ts
@@ -22237,6 +22558,18 @@ var PLUGINS = [
   }
 ];
 var SKILLS = [
+  {
+    id: "find-skills",
+    name: "Find Skills",
+    type: "skill",
+    description: "Discover and install skills from the open agent skills ecosystem - essential for any AI workflow",
+    installCommand: "npx skills add vercel-labs/skills@find-skills --yes",
+    phases: ["requirements", "planning", "implementation", "review"],
+    impact: "high",
+    detectionKey: "find-skills",
+    website: "https://skills.sh/vercel-labs/skills/find-skills",
+    badge: "Essential"
+  },
   {
     id: "tdd-skill",
     name: "Test-Driven Development",
@@ -22760,16 +23093,16 @@ var doctorCommand = defineCommand2({
     results.push({ label: "OS", status: "info", value: `${process.platform} ${process.arch}` });
     results.push({ label: "Bun", status: "info", value: typeof Bun !== "undefined" ? Bun.version : "N/A" });
     results.push({ label: "Node", status: "info", value: process.version });
-    results.push({ label: "Home", status: "info", value: homedir10() });
-    const gitDir = join13(process.cwd(), ".git");
-    if (existsSync13(gitDir)) {
+    results.push({ label: "Home", status: "info", value: homedir11() });
+    const gitDir = join14(process.cwd(), ".git");
+    if (existsSync14(gitDir)) {
       results.push({ label: "Git", status: "success", value: "Repository detected" });
     } else {
       results.push({ label: "Git", status: "warn", value: "No repository in current directory" });
     }
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir10());
-      if (existsSync13(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir11());
+      if (existsSync14(resolvedPath)) {
         results.push({ label: agent, status: "success", value: `found at ${resolvedPath}` });
       }
     }
@@ -22823,10 +23156,10 @@ var doctorCommand = defineCommand2({
 });
 
 // src/commands/setup.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, copyFileSync } from "node:fs";
-import { join as join14, dirname as dirname2 } from "node:path";
-import { homedir as homedir11, platform as platform2 } from "node:os";
-import { execSync as execSync3 } from "node:child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, copyFileSync } from "node:fs";
+import { join as join15, dirname as dirname2 } from "node:path";
+import { homedir as homedir12, platform as platform2 } from "node:os";
+import { execSync as execSync4 } from "node:child_process";
 import { createInterface } from "node:readline";
 var CONVEX_SITE_URL = "https://steady-bass-841.convex.site";
 async function fetchSetupData() {
@@ -22844,7 +23177,7 @@ var FALLBACK_HARNESSES = [
     id: "claude-code",
     name: "Claude Code",
     configPaths: [
-      join14(homedir11(), ".claude.json")
+      join15(homedir12(), ".claude.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -22853,8 +23186,8 @@ var FALLBACK_HARNESSES = [
     id: "opencode",
     name: "OpenCode",
     configPaths: [
-      join14(homedir11(), ".opencode.json"),
-      join14(homedir11(), ".config", "opencode", "opencode.json")
+      join15(homedir12(), ".opencode.json"),
+      join15(homedir12(), ".config", "opencode", "opencode.json")
     ],
     mcpConfigKey: "mcp",
     detected: false
@@ -22863,8 +23196,8 @@ var FALLBACK_HARNESSES = [
     id: "cursor",
     name: "Cursor",
     configPaths: [
-      join14(homedir11(), ".cursor", "mcp.json"),
-      join14(homedir11(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
+      join15(homedir12(), ".cursor", "mcp.json"),
+      join15(homedir12(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -22881,7 +23214,7 @@ function getConfigPathsForPlatform(harness) {
   } else {
     paths = pathMap.linux;
   }
-  return paths.map((p) => p.replace(/^~/, homedir11()).replace(/%USERPROFILE%/gi, homedir11()).replace(/%APPDATA%/gi, join14(homedir11(), "AppData", "Roaming")));
+  return paths.map((p) => p.replace(/^~/, homedir12()).replace(/%USERPROFILE%/gi, homedir12()).replace(/%APPDATA%/gi, join15(homedir12(), "AppData", "Roaming")));
 }
 function convertAPIHarnessToConfig(harness) {
   return {
@@ -22896,7 +23229,7 @@ function detectHarnesses(harnesses) {
   const detected = [];
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (existsSync14(configPath)) {
+      if (existsSync15(configPath)) {
         detected.push({
           ...harness,
           detected: true,
@@ -22909,19 +23242,19 @@ function detectHarnesses(harnesses) {
   return detected;
 }
 function backupConfig(configPath) {
-  const backupDir = join14(homedir11(), ".nairon", "backups");
-  if (!existsSync14(backupDir)) {
-    mkdirSync5(backupDir, { recursive: true });
+  const backupDir = join15(homedir12(), ".nairon", "backups");
+  if (!existsSync15(backupDir)) {
+    mkdirSync6(backupDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = configPath.replace(/[/\\]/g, "_").replace(/^_/, "");
-  const backupPath = join14(backupDir, `${timestamp}_${filename}`);
+  const backupPath = join15(backupDir, `${timestamp}_${filename}`);
   copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function readJsonConfig(configPath) {
   try {
-    const content = readFileSync13(configPath, "utf-8");
+    const content = readFileSync14(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -22929,10 +23262,10 @@ function readJsonConfig(configPath) {
 }
 function writeJsonConfig(configPath, config) {
   const dir = dirname2(configPath);
-  if (!existsSync14(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync15(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  writeFileSync6(configPath, JSON.stringify(config, null, 2));
+  writeFileSync7(configPath, JSON.stringify(config, null, 2));
 }
 async function prompt2(question) {
   const rl = createInterface({
@@ -22973,7 +23306,7 @@ function getInstalledMCPs(harnesses) {
   const installed = new Set;
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (!existsSync14(configPath))
+      if (!existsSync15(configPath))
         continue;
       const config = readJsonConfig(configPath);
       const mcpServers = config[harness.mcpConfigKey];
@@ -22997,7 +23330,7 @@ async function installMCPServer(serverName, instruction, harness) {
   if (!harness.configPath || !instruction.mcpServerConfig)
     return false;
   try {
-    if (existsSync14(harness.configPath)) {
+    if (existsSync15(harness.configPath)) {
       backupConfig(harness.configPath);
     }
     const config = readJsonConfig(harness.configPath);
@@ -23025,16 +23358,16 @@ async function installMCPServer(serverName, instruction, harness) {
 async function installBeads(projectDir) {
   try {
     try {
-      execSync3("bd --version", { stdio: "ignore" });
+      execSync4("bd --version", { stdio: "ignore" });
     } catch {
       const spinner = createSpinner("Installing Beads globally...");
       spinner.start();
       try {
-        execSync3("bun add -g beads", { stdio: "ignore" });
+        execSync4("bun add -g beads", { stdio: "ignore" });
         spinner.succeed("Beads installed globally");
       } catch {
         try {
-          execSync3("npm install -g beads", { stdio: "ignore" });
+          execSync4("npm install -g beads", { stdio: "ignore" });
           spinner.succeed("Beads installed globally (via npm)");
         } catch {
           spinner.fail("Failed to install Beads globally");
@@ -23042,13 +23375,13 @@ async function installBeads(projectDir) {
         }
       }
     }
-    const beadsDir = join14(projectDir, ".beads");
-    if (!existsSync14(beadsDir)) {
+    const beadsDir = join15(projectDir, ".beads");
+    if (!existsSync15(beadsDir)) {
       const projectName = projectDir.split(/[/\\]/).pop() ?? "project";
       const initSpinner = createSpinner(`Initializing Beads in ${projectName}...`);
       initSpinner.start();
       try {
-        execSync3(`bd init ${projectName}`, { cwd: projectDir, stdio: "ignore" });
+        execSync4(`bd init ${projectName}`, { cwd: projectDir, stdio: "ignore" });
         initSpinner.succeed(`Beads initialized in ${projectName}`);
       } catch {
         initSpinner.fail("Failed to initialize Beads in project");
@@ -23062,9 +23395,9 @@ async function installBeads(projectDir) {
   }
 }
 async function createClaudeRules(projectDir) {
-  const claudeMdPath = join14(projectDir, "CLAUDE.md");
-  const agentsMdPath = join14(projectDir, "AGENTS.md");
-  if (existsSync14(claudeMdPath) || existsSync14(agentsMdPath)) {
+  const claudeMdPath = join15(projectDir, "CLAUDE.md");
+  const agentsMdPath = join15(projectDir, "AGENTS.md");
+  if (existsSync15(claudeMdPath) || existsSync15(agentsMdPath)) {
     console.log(`  ${icons.info} CLAUDE.md or AGENTS.md already exists`);
     return true;
   }
@@ -23098,7 +23431,7 @@ bun run build
 Use conventional commits: feat:, fix:, docs:, refactor:, test:, chore:
 `;
   try {
-    writeFileSync6(claudeMdPath, content);
+    writeFileSync7(claudeMdPath, content);
     return true;
   } catch {
     return false;
@@ -23378,7 +23711,7 @@ var setupCommand = defineCommand2({
 });
 
 // src/commands/upgrade.ts
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 var CYAN = "\x1B[36m";
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
@@ -23387,6 +23720,27 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    version: "0.5.2",
+    date: "2026-02-14",
+    title: "Multi-Agent Detection",
+    highlights: [
+      "Detects ALL installed AI agents (Claude Code, Cursor, OpenCode, Codex, etc.)",
+      "Choose which agent you're using if multiple are found",
+      "Expanded agent support: Copilot, Cody, Aider"
+    ]
+  },
+  {
+    version: "0.5.1",
+    date: "2026-02-14",
+    title: "Smart Project Onboarding",
+    highlights: [
+      "First scan detects your project and suggests relevant skills",
+      "Auto-installs find-skills to discover more tools later",
+      "Analyzes README to recommend skills for your tech stack",
+      "Detects your AI agent (Claude Code, OpenCode, Cursor)"
+    ]
+  },
   {
     version: "0.5.0",
     date: "2026-02-14",
@@ -23703,7 +24057,7 @@ var upgradeCommand = defineCommand2({
     console.log(`${DIM}  Checking for updates...${RESET}`);
     let latestVersion;
     try {
-      latestVersion = execSync4("npm view nairon-bench version", { encoding: "utf-8" }).trim();
+      latestVersion = execSync5("npm view nairon-bench version", { encoding: "utf-8" }).trim();
     } catch {
       console.log(`  ${YELLOW}⚠${RESET} Could not check npm registry`);
       console.log(`  ${DIM}Run 'bun add -g nairon-bench@latest' manually${RESET}`);
@@ -23730,7 +24084,7 @@ var upgradeCommand = defineCommand2({
     console.log(`  ${CYAN}↓${RESET} Upgrading to ${GREEN}v${latestVersion}${RESET}...`);
     console.log();
     try {
-      execSync4("npm install -g nairon-bench@latest", {
+      execSync5("npm install -g nairon-bench@latest", {
         stdio: "inherit",
         env: { ...process.env, npm_config_fund: "false" }
       });
@@ -23748,7 +24102,7 @@ var upgradeCommand = defineCommand2({
 });
 function getCurrentVersion() {
   try {
-    const output = execSync4("nb --version 2>/dev/null || nairon-bench --version 2>/dev/null", {
+    const output = execSync5("nb --version 2>/dev/null || nairon-bench --version 2>/dev/null", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -23837,7 +24191,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.5.0",
+  version: "0.5.2",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -23845,7 +24199,8 @@ var package_default = {
     nb: "./dist/index.js"
   },
   files: [
-    "dist"
+    "dist",
+    "postinstall.js"
   ],
   repository: {
     type: "git",
@@ -23873,7 +24228,8 @@ var package_default = {
     "test:e2e": "vitest run tests/e2e/",
     "test:watch": "vitest",
     clean: "rm -rf dist",
-    prepublishOnly: "bun run build"
+    prepublishOnly: "bun run build",
+    postinstall: "node postinstall.js || true"
   },
   dependencies: {
     "cli-boxes": "^4.0.1",
@@ -23896,9 +24252,9 @@ var versionCommand = defineCommand2({
 
 // src/commands/init.ts
 init_dist();
-import { existsSync as existsSync15 } from "node:fs";
-import { homedir as homedir12, platform as platform3, arch } from "node:os";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { homedir as homedir13, platform as platform3, arch } from "node:os";
+import { join as join16 } from "node:path";
 init_client();
 
 // src/lib/github-auth.ts
@@ -24068,8 +24424,8 @@ var initCommand = defineCommand2({
     consola.start("Step 2/6: Detecting AI agents...");
     const detectedAgents = [];
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir12());
-      if (existsSync15(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir13());
+      if (existsSync16(resolvedPath)) {
         detectedAgents.push(agent);
         consola.success(`  Found: ${agent}`);
       }
@@ -24172,7 +24528,7 @@ var initCommand = defineCommand2({
       { name: "playwright", configs: ["playwright.config.ts", "playwright.config.js"] }
     ];
     for (const fw of testFrameworks) {
-      if (fw.configs.some((c3) => existsSync15(join15(process.cwd(), c3)))) {
+      if (fw.configs.some((c3) => existsSync16(join16(process.cwd(), c3)))) {
         toolStack.testing.push(fw.name);
       }
     }
@@ -24241,13 +24597,13 @@ var initCommand = defineCommand2({
 });
 function detectPackageManager() {
   const cwd = process.cwd();
-  if (existsSync15(join15(cwd, "bun.lock")) || existsSync15(join15(cwd, "bun.lockb")))
+  if (existsSync16(join16(cwd, "bun.lock")) || existsSync16(join16(cwd, "bun.lockb")))
     return "bun";
-  if (existsSync15(join15(cwd, "pnpm-lock.yaml")))
+  if (existsSync16(join16(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync15(join15(cwd, "yarn.lock")))
+  if (existsSync16(join16(cwd, "yarn.lock")))
     return "yarn";
-  if (existsSync15(join15(cwd, "package-lock.json")))
+  if (existsSync16(join16(cwd, "package-lock.json")))
     return "npm";
   return;
 }
@@ -24262,15 +24618,15 @@ var CLAUDE_CODE_SKILLS = [
 ];
 function detectEasyWins(detectedAgents) {
   const wins = [];
-  const home = homedir12();
+  const home = homedir13();
   const hasClaudeCode = detectedAgents.some((a2) => a2.toLowerCase().includes("claude") || a2.toLowerCase().includes("opencode"));
-  const claudeConfigDir = join15(home, ".claude");
-  const hasClaudeConfig = existsSync15(claudeConfigDir);
+  const claudeConfigDir = join16(home, ".claude");
+  const hasClaudeConfig = existsSync16(claudeConfigDir);
   if (hasClaudeCode || hasClaudeConfig) {
-    const skillsDir = join15(home, ".claude", "skills");
+    const skillsDir = join16(home, ".claude", "skills");
     for (const skill of CLAUDE_CODE_SKILLS) {
-      const skillPath = join15(skillsDir, skill.id);
-      const isInstalled = existsSync15(skillPath);
+      const skillPath = join16(skillsDir, skill.id);
+      const isInstalled = existsSync16(skillPath);
       if (!isInstalled) {
         wins.push({
           icon: skill.icon,
@@ -24286,12 +24642,12 @@ function detectEasyWins(detectedAgents) {
 // src/commands/onboard.ts
 init_dist();
 init_client();
-import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync7, readdirSync as readdirSync9 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync8, readdirSync as readdirSync9 } from "node:fs";
+import { join as join18 } from "node:path";
 
 // src/lib/project-context-detector.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
-import { join as join16, basename as basename4 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "node:fs";
+import { join as join17, basename as basename4 } from "node:path";
 function detectProjectContext(projectDir) {
   const projectName = basename4(projectDir);
   const projectId = generateProjectId(projectDir);
@@ -24327,11 +24683,11 @@ function detectTechStack(projectDir) {
   };
 }
 function readPackageJson(projectDir) {
-  const pkgPath = join16(projectDir, "package.json");
-  if (!existsSync16(pkgPath))
+  const pkgPath = join17(projectDir, "package.json");
+  if (!existsSync17(pkgPath))
     return {};
   try {
-    return JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    return JSON.parse(readFileSync15(pkgPath, "utf-8"));
   } catch {
     return {};
   }
@@ -24352,34 +24708,34 @@ function detectFramework(deps) {
   return null;
 }
 function detectMetaFramework(deps, projectDir) {
-  if (deps.next || existsSync16(join16(projectDir, "next.config.js")) || existsSync16(join16(projectDir, "next.config.mjs")))
+  if (deps.next || existsSync17(join17(projectDir, "next.config.js")) || existsSync17(join17(projectDir, "next.config.mjs")))
     return "next";
-  if (deps.nuxt || existsSync16(join16(projectDir, "nuxt.config.ts")))
+  if (deps.nuxt || existsSync17(join17(projectDir, "nuxt.config.ts")))
     return "nuxt";
   if (deps["@sveltejs/kit"])
     return "sveltekit";
-  if (deps.astro || existsSync16(join16(projectDir, "astro.config.mjs")))
+  if (deps.astro || existsSync17(join17(projectDir, "astro.config.mjs")))
     return "astro";
   if (deps["@remix-run/react"])
     return "remix";
   if (deps.gatsby)
     return "gatsby";
-  if (deps.vite || existsSync16(join16(projectDir, "vite.config.ts")))
+  if (deps.vite || existsSync17(join17(projectDir, "vite.config.ts")))
     return "vite";
   return null;
 }
 function detectRuntime(projectDir) {
-  if (existsSync16(join16(projectDir, "bun.lockb")) || existsSync16(join16(projectDir, "bun.lock")))
+  if (existsSync17(join17(projectDir, "bun.lockb")) || existsSync17(join17(projectDir, "bun.lock")))
     return "bun";
-  if (existsSync16(join16(projectDir, "deno.json")) || existsSync16(join16(projectDir, "deno.lock")))
+  if (existsSync17(join17(projectDir, "deno.json")) || existsSync17(join17(projectDir, "deno.lock")))
     return "deno";
   return "node";
 }
 function detectLanguage(projectDir) {
-  if (existsSync16(join16(projectDir, "tsconfig.json")))
+  if (existsSync17(join17(projectDir, "tsconfig.json")))
     return "typescript";
-  const srcDir = join16(projectDir, "src");
-  if (existsSync16(srcDir)) {
+  const srcDir = join17(projectDir, "src");
+  if (existsSync17(srcDir)) {
     try {
       const files = readdirSync8(srcDir);
       if (files.some((f3) => f3.endsWith(".ts") || f3.endsWith(".tsx")))
@@ -24390,7 +24746,7 @@ function detectLanguage(projectDir) {
 }
 function detectStyling(deps, projectDir) {
   const tools = [];
-  if (deps.tailwindcss || existsSync16(join16(projectDir, "tailwind.config.js")) || existsSync16(join16(projectDir, "tailwind.config.ts")))
+  if (deps.tailwindcss || existsSync17(join17(projectDir, "tailwind.config.js")) || existsSync17(join17(projectDir, "tailwind.config.ts")))
     tools.push("tailwind");
   if (deps["styled-components"])
     tools.push("styled-components");
@@ -24435,13 +24791,13 @@ function detectORM(deps) {
 }
 function detectTesting(deps, projectDir) {
   const tools = [];
-  if (deps.vitest || existsSync16(join16(projectDir, "vitest.config.ts")))
+  if (deps.vitest || existsSync17(join17(projectDir, "vitest.config.ts")))
     tools.push("vitest");
-  if (deps.jest || existsSync16(join16(projectDir, "jest.config.js")))
+  if (deps.jest || existsSync17(join17(projectDir, "jest.config.js")))
     tools.push("jest");
-  if (deps["@playwright/test"] || existsSync16(join16(projectDir, "playwright.config.ts")))
+  if (deps["@playwright/test"] || existsSync17(join17(projectDir, "playwright.config.ts")))
     tools.push("playwright");
-  if (deps.cypress || existsSync16(join16(projectDir, "cypress.config.ts")))
+  if (deps.cypress || existsSync17(join17(projectDir, "cypress.config.ts")))
     tools.push("cypress");
   if (deps["@testing-library/react"] || deps["@testing-library/vue"])
     tools.push("testing-library");
@@ -24473,7 +24829,7 @@ function detectBuildTools(deps, projectDir) {
     tools.push("esbuild");
   if (deps.webpack)
     tools.push("webpack");
-  if (deps.turbo || existsSync16(join16(projectDir, "turbo.json")))
+  if (deps.turbo || existsSync17(join17(projectDir, "turbo.json")))
     tools.push("turborepo");
   if (deps.tsup)
     tools.push("tsup");
@@ -24483,17 +24839,17 @@ function detectBuildTools(deps, projectDir) {
 }
 function detectDeployment(projectDir) {
   const tools = [];
-  if (existsSync16(join16(projectDir, "vercel.json")) || existsSync16(join16(projectDir, ".vercel")))
+  if (existsSync17(join17(projectDir, "vercel.json")) || existsSync17(join17(projectDir, ".vercel")))
     tools.push("vercel");
-  if (existsSync16(join16(projectDir, "netlify.toml")))
+  if (existsSync17(join17(projectDir, "netlify.toml")))
     tools.push("netlify");
-  if (existsSync16(join16(projectDir, "fly.toml")))
+  if (existsSync17(join17(projectDir, "fly.toml")))
     tools.push("fly");
-  if (existsSync16(join16(projectDir, "railway.json")))
+  if (existsSync17(join17(projectDir, "railway.json")))
     tools.push("railway");
-  if (existsSync16(join16(projectDir, "Dockerfile")))
+  if (existsSync17(join17(projectDir, "Dockerfile")))
     tools.push("docker");
-  if (existsSync16(join16(projectDir, ".github", "workflows")))
+  if (existsSync17(join17(projectDir, ".github", "workflows")))
     tools.push("github-actions");
   return tools;
 }
@@ -24516,20 +24872,20 @@ function detectAIML(deps) {
   return tools;
 }
 function inferProjectType(projectDir, techStack) {
-  if (existsSync16(join16(projectDir, "packages")) || existsSync16(join16(projectDir, "apps"))) {
+  if (existsSync17(join17(projectDir, "packages")) || existsSync17(join17(projectDir, "apps"))) {
     return "monorepo";
   }
   const pkg = readPackageJson(projectDir);
-  if (pkg.bin || existsSync16(join16(projectDir, "src", "cli.ts")) || existsSync16(join16(projectDir, "src", "index.ts"))) {
+  if (pkg.bin || existsSync17(join17(projectDir, "src", "cli.ts")) || existsSync17(join17(projectDir, "src", "index.ts"))) {
     const hasBin = !!pkg.bin;
-    const hasCommands = existsSync16(join16(projectDir, "src", "commands"));
+    const hasCommands = existsSync17(join17(projectDir, "src", "commands"));
     if (hasBin || hasCommands)
       return "cli";
   }
   if (!techStack.framework && !techStack.metaFramework && pkg.main) {
     return "library";
   }
-  if (existsSync16(join16(projectDir, "app.json")) || existsSync16(join16(projectDir, "expo"))) {
+  if (existsSync17(join17(projectDir, "app.json")) || existsSync17(join17(projectDir, "expo"))) {
     return "mobile";
   }
   if (techStack.database.length > 0 && !techStack.framework) {
@@ -24546,10 +24902,10 @@ function extractDescription(projectDir) {
     return pkg.description;
   const readmePaths = ["README.md", "readme.md", "Readme.md"];
   for (const readme of readmePaths) {
-    const path = join16(projectDir, readme);
-    if (existsSync16(path)) {
+    const path = join17(projectDir, readme);
+    if (existsSync17(path)) {
       try {
-        const content = readFileSync14(path, "utf-8");
+        const content = readFileSync15(path, "utf-8");
         const lines = content.split(`
 `);
         let foundTitle = false;
@@ -25967,9 +26323,9 @@ var onboardCommand = defineCommand2({
   },
   async run({ args }) {
     const projectPath = process.cwd();
-    const contextPath = join17(projectPath, ".nairon", "context.json");
-    if (existsSync17(contextPath) && !args.force) {
-      const existing = JSON.parse(readFileSync15(contextPath, "utf-8"));
+    const contextPath = join18(projectPath, ".nairon", "context.json");
+    if (existsSync18(contextPath) && !args.force) {
+      const existing = JSON.parse(readFileSync16(contextPath, "utf-8"));
       consola.info("Project already onboarded. Use --force to re-run.");
       consola.info(`Business: ${existing.businessContext?.domain || existing.businessContext?.slice?.(0, 50) || "Not set"}...`);
       consola.info(`Stack: ${formatTechStackSummary(existing)}`);
@@ -26117,11 +26473,11 @@ var onboardCommand = defineCommand2({
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     };
-    const naironDir = join17(projectPath, ".nairon");
-    if (!existsSync17(naironDir)) {
-      mkdirSync6(naironDir, { recursive: true });
+    const naironDir = join18(projectPath, ".nairon");
+    if (!existsSync18(naironDir)) {
+      mkdirSync7(naironDir, { recursive: true });
     }
-    writeFileSync7(contextPath, JSON.stringify(fullContext, null, 2));
+    writeFileSync8(contextPath, JSON.stringify(fullContext, null, 2));
     consola.success(`Saved to ${contextPath}`);
     if (isSupermemoryConfigured()) {
       consola.start("Storing in Supermemory...");
@@ -26209,51 +26565,51 @@ function formatTechStackSummary(context) {
 function detectInstalledTools(projectPath) {
   const tools = [];
   const home = process.env.HOME || "";
-  const userClaudeJson = join17(home, ".claude.json");
-  if (existsSync17(userClaudeJson)) {
+  const userClaudeJson = join18(home, ".claude.json");
+  if (existsSync18(userClaudeJson)) {
     try {
-      const config = JSON.parse(readFileSync15(userClaudeJson, "utf-8"));
+      const config = JSON.parse(readFileSync16(userClaudeJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const claudeDesktopConfig = join17(home, ".claude", "claude_desktop_config.json");
-  if (existsSync17(claudeDesktopConfig)) {
+  const claudeDesktopConfig = join18(home, ".claude", "claude_desktop_config.json");
+  if (existsSync18(claudeDesktopConfig)) {
     try {
-      const config = JSON.parse(readFileSync15(claudeDesktopConfig, "utf-8"));
+      const config = JSON.parse(readFileSync16(claudeDesktopConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectMcpJson = join17(projectPath, ".mcp.json");
-  if (existsSync17(projectMcpJson)) {
+  const projectMcpJson = join18(projectPath, ".mcp.json");
+  if (existsSync18(projectMcpJson)) {
     try {
-      const config = JSON.parse(readFileSync15(projectMcpJson, "utf-8"));
+      const config = JSON.parse(readFileSync16(projectMcpJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectClaudeConfig = join17(projectPath, ".claude", "settings.json");
-  if (existsSync17(projectClaudeConfig)) {
+  const projectClaudeConfig = join18(projectPath, ".claude", "settings.json");
+  if (existsSync18(projectClaudeConfig)) {
     try {
-      const config = JSON.parse(readFileSync15(projectClaudeConfig, "utf-8"));
+      const config = JSON.parse(readFileSync16(projectClaudeConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const skillsDir = join17(home, ".config", "opencode", "skills");
-  if (existsSync17(skillsDir)) {
+  const skillsDir = join18(home, ".config", "opencode", "skills");
+  if (existsSync18(skillsDir)) {
     try {
       const skills = readdirSync9(skillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
     } catch {}
   }
-  const agentsSkillsDir = join17(home, ".agents", "skills");
-  if (existsSync17(agentsSkillsDir)) {
+  const agentsSkillsDir = join18(home, ".agents", "skills");
+  if (existsSync18(agentsSkillsDir)) {
     try {
       const skills = readdirSync9(agentsSkillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
@@ -26263,11 +26619,11 @@ function detectInstalledTools(projectPath) {
 }
 function detectPrimaryAgent() {
   const home = process.env.HOME || "";
-  if (existsSync17(join17(home, ".claude")))
+  if (existsSync18(join18(home, ".claude")))
     return "claude-code";
-  if (existsSync17(join17(home, ".cursor")))
+  if (existsSync18(join18(home, ".cursor")))
     return "cursor";
-  if (existsSync17(join17(home, ".config", "opencode")))
+  if (existsSync18(join18(home, ".config", "opencode")))
     return "opencode";
   return;
 }
@@ -26362,7 +26718,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.5.0",
+  version: "0.5.2",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -26370,7 +26726,8 @@ var package_default2 = {
     nb: "./dist/index.js"
   },
   files: [
-    "dist"
+    "dist",
+    "postinstall.js"
   ],
   repository: {
     type: "git",
@@ -26398,7 +26755,8 @@ var package_default2 = {
     "test:e2e": "vitest run tests/e2e/",
     "test:watch": "vitest",
     clean: "rm -rf dist",
-    prepublishOnly: "bun run build"
+    prepublishOnly: "bun run build",
+    postinstall: "node postinstall.js || true"
   },
   dependencies: {
     "cli-boxes": "^4.0.1",
@@ -26463,7 +26821,7 @@ var hasVersion = args.includes("--version");
 if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
   showBanner();
 } else {
-  const main = defineCommand({
+  const cmd = defineCommand({
     meta: {
       name: "nairon-bench",
       version: VERSION2,
@@ -26481,5 +26839,5 @@ if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
       cache: cacheCommand
     }
   });
-  runMain(main);
+  runMain(cmd);
 }