nairon-bench 0.0.40 → 0.2.0

package/dist/index.js

@@ -14181,6 +14181,11 @@ var scanCommand = defineCommand2({
       description: "Disable session caching (slower but ensures fresh data)",
       default: false
     },
+    "no-recommend": {
+      type: "boolean",
+      description: "Skip showing recommendations after scan",
+      default: false
+    },
     watch: {
       type: "boolean",
       alias: "w",
@@ -14360,6 +14365,9 @@ var scanCommand = defineCommand2({
         const reportPath = generateReport(reportDir, score, git, agents, tests, args.since, sdlcAnalysis, scanCost, analysis);
         console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
       }
+      if (!args["no-recommend"]) {
+        await showQuickRecommendations(analysis, agents, tests, projectDir);
+      }
     }
     if (args.offline) {
       if (!silent) {
@@ -14656,6 +14664,67 @@ function formatTokensPlain(tokens) {
     return `${Math.round(tokens / 1000)}K`;
   return tokens.toString();
 }
+async function showQuickRecommendations(analysis, agents, tests, projectDir) {
+  const suggestions = [];
+  if (analysis.sessionPatterns.memoryLossCount > 2 || analysis.sessionPatterns.contextCompactions > 3) {
+    suggestions.push({
+      icon: "\uD83E\uDDE0",
+      text: "Frequent context loss detected",
+      tool: "Supermemory"
+    });
+  }
+  if (!analysis.environment.hasContext7 && analysis.sessionPatterns.toolFailures > 2) {
+    suggestions.push({
+      icon: "\uD83D\uDCDA",
+      text: "API hallucinations likely",
+      tool: "Context7"
+    });
+  }
+  if (!tests || tests.totalTests === 0) {
+    suggestions.push({
+      icon: "\uD83E\uDDEA",
+      text: "No tests detected",
+      tool: "Agentic TDD workflow"
+    });
+  }
+  if (analysis.sessionPatterns.longBackForth > 2) {
+    suggestions.push({
+      icon: "\uD83D\uDCAC",
+      text: "Excessive back-and-forth in sessions",
+      tool: "Skills/structured prompts"
+    });
+  }
+  if (!analysis.environment.hasBeads && agents && agents.totalSessions > 5) {
+    suggestions.push({
+      icon: "\uD83D\uDCCB",
+      text: "No persistent task tracking",
+      tool: "Beads"
+    });
+  }
+  if (analysis.efficiency.tokensWastedWeekly > 50000) {
+    suggestions.push({
+      icon: "\uD83D\uDCB0",
+      text: `~${formatTokensPlain(analysis.efficiency.tokensWastedWeekly)} tokens wasted/week`,
+      tool: "Token optimization"
+    });
+  }
+  if (suggestions.length === 0) {
+    return;
+  }
+  const toShow = suggestions.slice(0, 3);
+  console.log();
+  console.log(`  ${colors2.bold(colors2.primary("Quick Recommendations"))}`);
+  console.log(colors2.dim("  " + "─".repeat(40)));
+  console.log();
+  for (const suggestion of toShow) {
+    const toolHint = suggestion.tool ? colors2.success(` → ${suggestion.tool}`) : "";
+    console.log(`  ${suggestion.icon} ${suggestion.text}${toolHint}`);
+    await sleep(100);
+  }
+  console.log();
+  console.log(`  ${colors2.dim(`Run ${colors2.primary("nb recommend")} for personalized tool suggestions`)}`);
+  console.log(`  ${colors2.dim(`Use ${colors2.primary("nb scan --no-recommend")} to skip this`)}`);
+}
 
 // src/commands/report.ts
 init_dist();
@@ -23629,10 +23698,1135 @@ var setupCommand = defineCommand2({
     }
   }
 });
+
+// src/commands/onboard.ts
+init_dist();
+init_client();
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join15, basename as basename5 } from "node:path";
+var TECH_PATTERNS = {
+  typescript: ["tsconfig.json", "*.ts", "*.tsx"],
+  javascript: ["*.js", "*.jsx", "*.mjs"],
+  python: ["*.py", "requirements.txt", "pyproject.toml", "setup.py"],
+  rust: ["Cargo.toml", "*.rs"],
+  go: ["go.mod", "*.go"],
+  nextjs: ["next.config.js", "next.config.ts", "next.config.mjs"],
+  react: ["package.json:react"],
+  vue: ["vue.config.js", "nuxt.config.ts", "package.json:vue"],
+  svelte: ["svelte.config.js", "package.json:svelte"],
+  astro: ["astro.config.mjs", "astro.config.ts"],
+  express: ["package.json:express"],
+  fastify: ["package.json:fastify"],
+  hono: ["package.json:hono"],
+  django: ["manage.py", "settings.py"],
+  flask: ["app.py:Flask"],
+  prisma: ["prisma/schema.prisma"],
+  drizzle: ["drizzle.config.ts"],
+  convex: ["convex/"],
+  supabase: [".supabase/", "supabase/"],
+  vitest: ["vitest.config.ts", "vitest.config.js"],
+  jest: ["jest.config.ts", "jest.config.js"],
+  playwright: ["playwright.config.ts"],
+  langchain: ["package.json:langchain", "requirements.txt:langchain"],
+  openai: ["package.json:openai", "requirements.txt:openai"],
+  anthropic: ["package.json:@anthropic-ai"]
+};
+var PROJECT_TYPES = {
+  "Web App": ["nextjs", "react", "vue", "svelte", "astro"],
+  "API/Backend": ["express", "fastify", "hono", "django", "flask"],
+  "CLI Tool": ["citty", "commander", "yargs"],
+  Library: ["tsup", "rollup", "esbuild"],
+  "Mobile App": ["react-native", "expo"],
+  "AI/ML": ["langchain", "openai", "anthropic"]
+};
+var onboardCommand = defineCommand2({
+  meta: {
+    name: "onboard",
+    description: "Set up project context for personalized AI workflow recommendations"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Re-run onboarding even if already configured",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const projectPath = process.cwd();
+    const contextPath = join15(projectPath, ".nairon", "context.json");
+    if (existsSync15(contextPath) && !args.force) {
+      const existing = JSON.parse(readFileSync12(contextPath, "utf-8"));
+      consola.info("Project already onboarded. Use --force to re-run.");
+      consola.info(`Business: ${existing.businessContext?.slice(0, 50)}...`);
+      consola.info(`Stack: ${existing.techStack?.join(", ")}`);
+      return;
+    }
+    consola.log("");
+    consola.box({
+      title: "Project Onboarding",
+      message: [
+        "Let's set up your project context for personalized recommendations.",
+        "",
+        "This helps Nairon Bench suggest tools and workflows",
+        "that are specifically relevant to YOUR project."
+      ].join(`
+`)
+    });
+    consola.log("");
+    consola.start("Step 1/4: Detecting tech stack...");
+    const { techStack, languages } = detectTechStack(projectPath);
+    const projectType = detectProjectType(techStack);
+    consola.success(`Detected: ${techStack.slice(0, 5).join(", ")}${techStack.length > 5 ? ` +${techStack.length - 5} more` : ""}`);
+    consola.info(`Project type: ${projectType}`);
+    const confirmStack = await consola.prompt("Is this correct?", {
+      type: "confirm",
+      initial: true
+    });
+    let finalStack = techStack;
+    if (confirmStack === false) {
+      const stackInput = await consola.prompt("Enter your tech stack (comma-separated):", {
+        type: "text",
+        default: techStack.join(", ")
+      });
+      if (typeof stackInput === "string") {
+        finalStack = stackInput.split(",").map((s2) => s2.trim()).filter(Boolean);
+      }
+    }
+    consola.log("");
+    consola.info("Step 2/4: Tell us about your project");
+    const businessContext = await consola.prompt("What are you building? (e.g., 'B2B SaaS for invoice automation', 'Personal blog with AI features')", {
+      type: "text",
+      placeholder: "Describe your project in 1-2 sentences"
+    });
+    if (typeof businessContext === "symbol" || !businessContext) {
+      consola.warn("Onboarding cancelled.");
+      return;
+    }
+    const targetUsers = await consola.prompt("Who are your target users? (e.g., 'SMB accountants', 'Developers', 'General consumers')", {
+      type: "text",
+      placeholder: "Describe your target audience"
+    });
+    if (typeof targetUsers === "symbol" || !targetUsers) {
+      consola.warn("Onboarding cancelled.");
+      return;
+    }
+    consola.log("");
+    consola.info("Step 3/4: What are your biggest workflow challenges?");
+    const painPointOptions = [
+      { label: "Finding the right context/docs for AI", value: "context" },
+      { label: "Long sessions that lose context", value: "session_length" },
+      { label: "AI hallucinations / wrong code", value: "hallucinations" },
+      { label: "Testing and debugging AI-generated code", value: "testing" },
+      { label: "Prompt engineering / getting good outputs", value: "prompting" },
+      { label: "Managing multiple AI tools", value: "tool_management" },
+      { label: "Cost management / token efficiency", value: "cost" }
+    ];
+    const selectedPainPoints = await consola.prompt("Select your top challenges:", {
+      type: "multiselect",
+      options: painPointOptions
+    });
+    const painPoints = Array.isArray(selectedPainPoints) ? selectedPainPoints.map((p) => typeof p === "string" ? p : p.value) : [];
+    consola.log("");
+    consola.start("Step 4/4: Detecting installed AI tools...");
+    const installedTools = detectInstalledTools(projectPath);
+    consola.success(`Found: ${installedTools.length > 0 ? installedTools.join(", ") : "None detected"}`);
+    const context = {
+      projectPath,
+      projectName: basename5(projectPath),
+      businessContext,
+      targetUsers,
+      techStack: finalStack,
+      detectedLanguages: languages,
+      painPoints,
+      installedTools,
+      primaryAgent: detectPrimaryAgent(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+    const naironDir = join15(projectPath, ".nairon");
+    if (!existsSync15(naironDir)) {
+      mkdirSync5(naironDir, { recursive: true });
+    }
+    writeFileSync7(contextPath, JSON.stringify(context, null, 2));
+    consola.success(`Saved to ${contextPath}`);
+    const client = getClient();
+    const config = getConfig();
+    if (client) {
+      consola.start("Syncing to cloud...");
+      try {
+        await client.mutation(api.nightcrawler.saveProjectContext, {
+          projectPath,
+          businessContext: context.businessContext,
+          targetUsers: context.targetUsers,
+          techStack: context.techStack,
+          detectedLanguages: context.detectedLanguages,
+          painPoints: context.painPoints,
+          installedTools: context.installedTools,
+          ...context.primaryAgent ? { primaryAgent: context.primaryAgent } : {}
+        });
+        consola.success("Project context synced to cloud");
+      } catch (err) {
+        consola.warn(`Cloud sync failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const recommendations = getQuickRecommendations(context);
+    consola.log("");
+    consola.box({
+      title: "Onboarding Complete!",
+      message: [
+        `Project: ${context.projectName}`,
+        `Type: ${projectType}`,
+        `Stack: ${finalStack.slice(0, 4).join(", ")}`,
+        `Pain points: ${painPoints.length} identified`,
+        "",
+        "Quick recommendations based on your profile:",
+        ...recommendations.map((r3) => `  ${r3.icon} ${r3.title}`),
+        "",
+        "Run 'nb recommend' for detailed suggestions",
+        "Run 'nb trending' to see what's hot in the community"
+      ].join(`
+`)
+    });
+  }
+});
+function detectTechStack(projectPath) {
+  const techStack = [];
+  const languages = [];
+  const pkgPath = join15(projectPath, "package.json");
+  let pkgJson = {};
+  if (existsSync15(pkgPath)) {
+    try {
+      pkgJson = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    } catch {}
+  }
+  const allDeps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies
+  };
+  for (const [tech, patterns] of Object.entries(TECH_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (pattern.startsWith("package.json:")) {
+        const dep = pattern.replace("package.json:", "");
+        if (allDeps[dep]) {
+          techStack.push(tech);
+          break;
+        }
+      } else if (pattern.includes("/")) {
+        if (existsSync15(join15(projectPath, pattern))) {
+          techStack.push(tech);
+          break;
+        }
+      } else if (!pattern.includes("*")) {
+        if (existsSync15(join15(projectPath, pattern))) {
+          techStack.push(tech);
+          break;
+        }
+      }
+    }
+  }
+  if (techStack.includes("typescript") || existsSync15(join15(projectPath, "tsconfig.json"))) {
+    languages.push("TypeScript");
+  }
+  if (techStack.includes("javascript") || pkgJson.name) {
+    languages.push("JavaScript");
+  }
+  if (techStack.includes("python") || existsSync15(join15(projectPath, "requirements.txt"))) {
+    languages.push("Python");
+  }
+  if (techStack.includes("rust"))
+    languages.push("Rust");
+  if (techStack.includes("go"))
+    languages.push("Go");
+  return { techStack, languages };
+}
+function detectProjectType(techStack) {
+  for (const [type, techs] of Object.entries(PROJECT_TYPES)) {
+    if (techs.some((t2) => techStack.includes(t2))) {
+      return type;
+    }
+  }
+  return "General";
+}
+function detectInstalledTools(projectPath) {
+  const tools = [];
+  const home = process.env.HOME || "";
+  const claudeConfigPath = join15(home, ".claude", "claude_desktop_config.json");
+  if (existsSync15(claudeConfigPath)) {
+    try {
+      const config = JSON.parse(readFileSync12(claudeConfigPath, "utf-8"));
+      if (config.mcpServers) {
+        tools.push(...Object.keys(config.mcpServers));
+      }
+    } catch {}
+  }
+  const projectClaudeConfig = join15(projectPath, ".claude", "settings.json");
+  if (existsSync15(projectClaudeConfig)) {
+    try {
+      const config = JSON.parse(readFileSync12(projectClaudeConfig, "utf-8"));
+      if (config.mcpServers) {
+        tools.push(...Object.keys(config.mcpServers));
+      }
+    } catch {}
+  }
+  const skillsDir = join15(home, ".claude", "skills");
+  if (existsSync15(skillsDir)) {
+    try {
+      const { readdirSync: readdirSync8 } = __require("fs");
+      const skills = readdirSync8(skillsDir);
+      tools.push(...skills.filter((s2) => !s2.startsWith(".")));
+    } catch {}
+  }
+  return [...new Set(tools)];
+}
+function detectPrimaryAgent() {
+  const home = process.env.HOME || "";
+  if (existsSync15(join15(home, ".claude")))
+    return "claude-code";
+  if (existsSync15(join15(home, ".cursor")))
+    return "cursor";
+  if (existsSync15(join15(home, ".config", "opencode")))
+    return "opencode";
+  return;
+}
+function getQuickRecommendations(context) {
+  const recs = [];
+  if (context.painPoints.includes("context") && !context.installedTools.includes("context7")) {
+    recs.push({ icon: "\uD83D\uDCDA", title: "Context7 MCP - Better library docs in context" });
+  }
+  if (context.painPoints.includes("session_length") && !context.installedTools.includes("supermemory")) {
+    recs.push({ icon: "\uD83E\uDDE0", title: "Supermemory - Persistent memory across sessions" });
+  }
+  if (context.painPoints.includes("testing")) {
+    recs.push({ icon: "\uD83E\uDDEA", title: "Agentic TDD workflow - AI-assisted test-driven dev" });
+  }
+  if (context.painPoints.includes("cost")) {
+    recs.push({ icon: "\uD83D\uDCB0", title: "OpenRouter - Route to cheapest model per task" });
+  }
+  if (context.painPoints.includes("prompting")) {
+    recs.push({ icon: "✨", title: "Structured prompting patterns from community" });
+  }
+  if (recs.length === 0) {
+    recs.push({ icon: "\uD83D\uDD25", title: "Run 'nb trending' to see what's hot" });
+  }
+  return recs.slice(0, 3);
+}
+
+// src/commands/trending.ts
+init_dist();
+init_client();
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+var MAGENTA = "\x1B[35m";
+var CATEGORY_ICONS = {
+  announcement: "\uD83D\uDCE2",
+  launch: "\uD83D\uDE80",
+  usage_pattern: "\uD83D\uDCA1",
+  tutorial: "\uD83D\uDCFA",
+  tip: "⚡"
+};
+var CATEGORY_LABELS = {
+  announcement: "ANNOUNCEMENTS",
+  launch: "LAUNCHES",
+  usage_pattern: "WORKFLOWS",
+  tutorial: "TUTORIALS",
+  tip: "TIPS"
+};
+var trendingCommand = defineCommand2({
+  meta: {
+    name: "trending",
+    description: "See what's hot in the AI dev tools community"
+  },
+  args: {
+    days: {
+      type: "string",
+      description: "Time range (1, 7, 30)",
+      default: "7"
+    },
+    category: {
+      type: "string",
+      description: "Filter by category (announcement, launch, usage_pattern, tutorial, tip)"
+    },
+    limit: {
+      type: "string",
+      description: "Max results per category",
+      default: "5"
+    },
+    tools: {
+      type: "boolean",
+      description: "Show top tools only",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const client = getClient();
+    if (!client) {
+      consola.error("Not connected to cloud. Run 'nb doctor' to check connection.");
+      return;
+    }
+    const days = parseInt(args.days) || 7;
+    const limit = parseInt(args.limit) || 5;
+    consola.log("");
+    console.log(`${YELLOW}\uD83D\uDD25 Hot Topics — Last ${days} Day${days > 1 ? "s" : ""}${RESET}`);
+    console.log(`${DIM}${"─".repeat(50)}${RESET}`);
+    try {
+      if (args.tools) {
+        await showTopTools(client, days, limit * 2);
+        return;
+      }
+      const insights = await client.query(api.nightcrawler.getRecentInsights, {
+        limit: 50,
+        maxHypeScore: 70,
+        ...args.category ? { category: args.category } : {}
+      });
+      if (insights.length === 0) {
+        consola.log("");
+        consola.warn("No trending insights found. The Nightcrawler may not have run yet.");
+        consola.info("Run the Nightcrawler manually or wait for the scheduled job.");
+        showFallbackMessage();
+        return;
+      }
+      const byCategory = {};
+      for (const insight of insights) {
+        const cat = insight.category;
+        if (!byCategory[cat]) {
+          byCategory[cat] = [];
+        }
+        byCategory[cat].push(insight);
+      }
+      const categoryOrder = ["announcement", "launch", "usage_pattern", "tutorial", "tip"];
+      for (const category of categoryOrder) {
+        const categoryInsights = byCategory[category];
+        if (!categoryInsights || categoryInsights.length === 0)
+          continue;
+        const icon = CATEGORY_ICONS[category] || "\uD83D\uDCCC";
+        const label = CATEGORY_LABELS[category] || category.toUpperCase();
+        consola.log("");
+        console.log(`${BOLD}${icon} ${label}${RESET}`);
+        for (const insight of categoryInsights.slice(0, limit)) {
+          const likes = formatNumber2(insight.engagement.likes);
+          const hasVideo = insight.hasVideo ? `${MAGENTA}▶${RESET} ` : "";
+          const tools = insight.toolsMentioned.length > 0 ? `${DIM}[${insight.toolsMentioned.slice(0, 2).join(", ")}]${RESET}` : "";
+          console.log(`${DIM}├─${RESET} ${hasVideo}${insight.keyInsight.slice(0, 60)}${insight.keyInsight.length > 60 ? "..." : ""}`);
+          console.log(`${DIM}│  ${RESET}${GREEN}${likes}❤${RESET}  @${insight.authorHandle} ${tools}`);
+        }
+        console.log(`${DIM}└─${RESET}`);
+      }
+      consola.log("");
+      await showTopTools(client, days, 5);
+      consola.log("");
+      console.log(`${DIM}Run 'nb trending --tools' for detailed tool rankings${RESET}`);
+      console.log(`${DIM}Run 'nb recommend' for personalized suggestions${RESET}`);
+    } catch (err) {
+      consola.error(`Failed to fetch trending: ${err instanceof Error ? err.message : String(err)}`);
+      showFallbackMessage();
+    }
+  }
+});
+async function showTopTools(client, days, limit) {
+  try {
+    const trending = await client.query(api.nightcrawler.getTrendingTools, {
+      days,
+      limit
+    });
+    if (trending.length === 0) {
+      console.log(`${DIM}No tool data available yet.${RESET}`);
+      return;
+    }
+    console.log(`${BOLD}\uD83D\uDEE0️  TOP TOOLS${RESET}`);
+    for (let i3 = 0;i3 < trending.length; i3++) {
+      const tool = trending[i3];
+      const rank = i3 + 1;
+      const bar = createBar(tool.mentions, trending[0].mentions);
+      const avgLikes = formatNumber2(tool.avgLikes);
+      console.log(`${DIM}${rank}.${RESET} ${CYAN}${tool.tool}${RESET}`);
+      console.log(`   ${bar} ${tool.mentions} mentions · ${avgLikes} avg❤`);
+    }
+  } catch (err) {
+    console.log(`${DIM}Could not fetch tool rankings.${RESET}`);
+  }
+}
+function showFallbackMessage() {
+  consola.log("");
+  consola.box({
+    title: "Nightcrawler Not Running",
+    message: [
+      "The trending data comes from the Nightcrawler background job",
+      "which scrapes X/Twitter for high-engagement dev tool posts.",
+      "",
+      "To populate data manually, run:",
+      "  cd skills/x-research",
+      '  bun run x-search.ts search "MCP server" --quick',
+      "",
+      "Or wait for the scheduled Nightcrawler job."
+    ].join(`
+`)
+  });
+}
+function formatNumber2(num) {
+  if (num >= 1e6)
+    return `${(num / 1e6).toFixed(1)}M`;
+  if (num >= 1000)
+    return `${(num / 1000).toFixed(1)}K`;
+  return num.toString();
+}
+function createBar(value, max, width = 15) {
+  const filled = Math.round(value / max * width);
+  const empty = width - filled;
+  return `${GREEN}${"█".repeat(filled)}${RESET}${DIM}${"░".repeat(empty)}${RESET}`;
+}
+
+// src/commands/recommend.ts
+init_dist();
+init_client();
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "node:fs";
+import { join as join16 } from "node:path";
+import { execSync as execSync5 } from "node:child_process";
+var CYAN2 = "\x1B[36m";
+var YELLOW2 = "\x1B[33m";
+var GREEN2 = "\x1B[32m";
+var RED = "\x1B[31m";
+var DIM2 = "\x1B[2m";
+var BOLD2 = "\x1B[1m";
+var RESET2 = "\x1B[0m";
+var MAGENTA2 = "\x1B[35m";
+var SKILLS_SH_MAPPINGS = {
+  testing: [
+    { skill: "obra/superpowers/test-driven-development", name: "Test-Driven Development", reason: "Agentic TDD workflow for writing tests first", installs: 8400 },
+    { skill: "anthropics/skills/webapp-testing", name: "Web App Testing", reason: "E2E testing patterns for web applications", installs: 9400 }
+  ],
+  debugging: [
+    { skill: "obra/superpowers/systematic-debugging", name: "Systematic Debugging", reason: "Structured approach to finding and fixing bugs", installs: 10100 }
+  ],
+  planning: [
+    { skill: "obra/superpowers/writing-plans", name: "Writing Plans", reason: "Better planning before implementation", installs: 8700 },
+    { skill: "obra/superpowers/executing-plans", name: "Executing Plans", reason: "Follow through on plans systematically", installs: 7700 }
+  ],
+  code_review: [
+    { skill: "obra/superpowers/requesting-code-review", name: "Requesting Code Review", reason: "Get better feedback on your code", installs: 7100 },
+    { skill: "obra/superpowers/receiving-code-review", name: "Receiving Code Review", reason: "Process and apply code review feedback", installs: 5900 }
+  ],
+  browser_testing: [
+    { skill: "vercel-labs/agent-browser/agent-browser", name: "Agent Browser", reason: "Browser automation for AI agents", installs: 33600 },
+    { skill: "browser-use/browser-use/browser-use", name: "Browser Use", reason: "Let AI control the browser", installs: 28500 }
+  ],
+  frontend: [
+    { skill: "anthropics/skills/frontend-design", name: "Frontend Design", reason: "Better UI/UX patterns for AI-generated code", installs: 65500 },
+    { skill: "vercel-labs/agent-skills/web-design-guidelines", name: "Web Design Guidelines", reason: "Design best practices", installs: 96100 }
+  ],
+  react: [
+    { skill: "vercel-labs/agent-skills/vercel-react-best-practices", name: "React Best Practices", reason: "Production-ready React patterns", installs: 128100 }
+  ],
+  nextjs: [
+    { skill: "vercel-labs/next-skills/next-best-practices", name: "Next.js Best Practices", reason: "App router patterns and optimizations", installs: 11200 }
+  ],
+  supabase: [
+    { skill: "supabase/agent-skills/supabase-postgres-best-practices", name: "Supabase Best Practices", reason: "Database and auth patterns", installs: 16700 }
+  ],
+  expo: [
+    { skill: "expo/skills/building-native-ui", name: "Building Native UI", reason: "React Native UI patterns", installs: 9500 }
+  ],
+  parallel_agents: [
+    { skill: "obra/superpowers/dispatching-parallel-agents", name: "Parallel Agents", reason: "Run multiple agents for faster work", installs: 5600 },
+    { skill: "obra/superpowers/subagent-driven-development", name: "Subagent Development", reason: "Delegate work to specialized agents", installs: 6400 }
+  ],
+  brainstorming: [
+    { skill: "obra/superpowers/brainstorming", name: "Brainstorming", reason: "Generate and evaluate ideas systematically", installs: 18300 }
+  ],
+  memory: [
+    { skill: "obra/episodic-memory/remembering-conversations", name: "Remembering Conversations", reason: "Persistent memory across sessions", installs: 4800 }
+  ]
+};
+var PAIN_POINT_TOOLS = {
+  context: [
+    { tool: "context7", reason: "Fetches up-to-date library docs directly into AI context", installCmd: "nb tools install context7" },
+    { tool: "nia", reason: "Index and search external repos, docs, and packages" }
+  ],
+  session_length: [
+    { tool: "supermemory", reason: "Persistent memory across sessions - never lose context", installCmd: "nb tools install supermemory" },
+    { tool: "beads", reason: "Task tracking that persists between sessions" }
+  ],
+  hallucinations: [
+    { tool: "context7", reason: "Real docs reduce hallucinations by 40%+", installCmd: "nb tools install context7" },
+    { tool: "repoprompt", reason: "Better context building for accurate code generation" }
+  ],
+  testing: [
+    { tool: "stagehand", reason: "AI-powered E2E testing with Playwright" },
+    { tool: "agentic-tdd", reason: "Test-driven development workflow for AI coding" }
+  ],
+  prompting: [
+    { tool: "skills", reason: "Pre-built prompt patterns for common tasks" },
+    { tool: "structured-prompts", reason: "Templates that get better AI outputs" }
+  ],
+  tool_management: [
+    { tool: "oh-my-opencode", reason: "Unified agent harness - one config for all tools" },
+    { tool: "mcp-installer", reason: "Easy MCP server management" }
+  ],
+  cost: [
+    { tool: "openrouter", reason: "Route to cheapest model per task", installCmd: "nb tools install openrouter" },
+    { tool: "token-counter", reason: "Track and optimize token usage" }
+  ]
+};
+var STACK_TOOLS = {
+  nextjs: [{ tool: "vercel-mcp", reason: "Deploy and manage Vercel projects from AI" }],
+  react: [{ tool: "storybook-mcp", reason: "AI-assisted component development" }],
+  typescript: [{ tool: "typescript-mcp", reason: "Better type inference in AI context" }],
+  prisma: [{ tool: "prisma-mcp", reason: "Database schema and queries in AI context" }],
+  convex: [{ tool: "convex-mcp", reason: "Convex functions and schema in AI context" }],
+  python: [{ tool: "python-mcp", reason: "Python environment and packages in AI context" }]
+};
+var recommendCommand = defineCommand2({
+  meta: {
+    name: "recommend",
+    description: "Get personalized AI workflow recommendations based on your project"
+  },
+  args: {
+    scan: {
+      type: "boolean",
+      description: "Re-analyze project before recommending",
+      default: false
+    },
+    limit: {
+      type: "string",
+      description: "Max recommendations to show",
+      default: "5"
+    },
+    all: {
+      type: "boolean",
+      description: "Show all recommendations (not just top)",
+      default: false
+    },
+    skills: {
+      type: "boolean",
+      description: "Show skills.sh recommendations based on workflow issues",
+      default: false
+    },
+    install: {
+      type: "boolean",
+      description: "Auto-install recommended skills from skills.sh",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const projectPath = process.cwd();
+    const contextPath = join16(projectPath, ".nairon", "context.json");
+    const limit = parseInt(args.limit) || 5;
+    consola.log("");
+    if (args.skills || args.install) {
+      await showSkillsRecommendations(projectPath, args.install);
+      return;
+    }
+    console.log(`${YELLOW2}\uD83D\uDCCA Analyzing your project...${RESET2}`);
+    let context = null;
+    if (existsSync16(contextPath)) {
+      try {
+        context = JSON.parse(readFileSync13(contextPath, "utf-8"));
+        console.log(`${DIM2}Loaded context from ${contextPath}${RESET2}`);
+      } catch {}
+    }
+    if (!context) {
+      consola.warn("No project context found. Run 'nb onboard' first for personalized recommendations.");
+      consola.log("");
+      await showGenericRecommendations();
+      return;
+    }
+    const recommendations = [];
+    for (const painPoint of context.painPoints) {
+      const tools = PAIN_POINT_TOOLS[painPoint] || [];
+      for (const tool of tools) {
+        if (!context.installedTools.includes(tool.tool)) {
+          recommendations.push({
+            tool: tool.tool,
+            reason: tool.reason,
+            source: "pain_point",
+            relevanceScore: 0.9,
+            installCmd: tool.installCmd
+          });
+        }
+      }
+    }
+    for (const tech of context.techStack) {
+      const tools = STACK_TOOLS[tech.toLowerCase()] || [];
+      for (const tool of tools) {
+        if (!context.installedTools.includes(tool.tool)) {
+          recommendations.push({
+            tool: tool.tool,
+            reason: tool.reason,
+            source: "stack",
+            relevanceScore: 0.7
+          });
+        }
+      }
+    }
+    const client = getClient();
+    if (client) {
+      try {
+        const trending = await client.query(api.nightcrawler.getRecommendationsForProject, {
+          projectPath,
+          limit: 10
+        });
+        for (const t2 of trending) {
+          if (recommendations.some((r3) => r3.tool === t2.toolSlug))
+            continue;
+          if (context.installedTools.includes(t2.toolSlug))
+            continue;
+          recommendations.push({
+            tool: t2.toolSlug,
+            reason: t2.reason,
+            source: "trending",
+            relevanceScore: t2.relevanceScore,
+            trendingMentions: t2.mentions
+          });
+        }
+      } catch (err) {}
+    }
+    const seen = new Set;
+    const uniqueRecs = recommendations.filter((r3) => {
+      if (seen.has(r3.tool))
+        return false;
+      seen.add(r3.tool);
+      return true;
+    }).sort((a2, b2) => b2.relevanceScore - a2.relevanceScore);
+    consola.log("");
+    console.log(`${BOLD2}${CYAN2}RECOMMENDATIONS FOR ${context.projectName.toUpperCase()}${RESET2}`);
+    console.log(`${DIM2}Based on: ${context.painPoints.length} pain points, ${context.techStack.length} stack items${RESET2}`);
+    console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+    const toShow = args.all ? uniqueRecs : uniqueRecs.slice(0, limit);
+    if (toShow.length === 0) {
+      consola.success("Your setup looks great! No new recommendations at this time.");
+      consola.log("");
+      console.log(`${DIM2}Run 'nb trending' to see what's new in the community${RESET2}`);
+      return;
+    }
+    for (let i3 = 0;i3 < toShow.length; i3++) {
+      const rec = toShow[i3];
+      const num = i3 + 1;
+      const sourceIcon = getSourceIcon(rec.source);
+      const trendingBadge = rec.trendingMentions ? `${MAGENTA2}↑${rec.trendingMentions}${RESET2} ` : "";
+      consola.log("");
+      console.log(`${BOLD2}${num}. ${CYAN2}${rec.tool}${RESET2} ${sourceIcon}`);
+      console.log(`   ${trendingBadge}${rec.reason}`);
+      if (rec.installCmd) {
+        console.log(`   ${DIM2}Install: ${GREEN2}${rec.installCmd}${RESET2}`);
+      }
+    }
+    consola.log("");
+    console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+    const painPointRecs = toShow.filter((r3) => r3.source === "pain_point").length;
+    const stackRecs = toShow.filter((r3) => r3.source === "stack").length;
+    const trendingRecs = toShow.filter((r3) => r3.source === "trending").length;
+    console.log(`${DIM2}${painPointRecs} for pain points · ${stackRecs} for your stack · ${trendingRecs} trending${RESET2}`);
+    if (!args.all && uniqueRecs.length > limit) {
+      console.log(`${DIM2}Run 'nb recommend --all' to see ${uniqueRecs.length - limit} more${RESET2}`);
+    }
+    if (context.installedTools.length > 0) {
+      consola.log("");
+      console.log(`${GREEN2}✓ Already installed:${RESET2} ${context.installedTools.slice(0, 5).join(", ")}${context.installedTools.length > 5 ? ` +${context.installedTools.length - 5} more` : ""}`);
+    }
+  }
+});
+async function showGenericRecommendations() {
+  console.log(`${BOLD2}${CYAN2}TOP COMMUNITY RECOMMENDATIONS${RESET2}`);
+  console.log(`${DIM2}Run 'nb onboard' for personalized suggestions${RESET2}`);
+  console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+  consola.log("");
+  const genericRecs = [
+    { tool: "context7", reason: "Up-to-date library docs in AI context - reduces hallucinations" },
+    { tool: "supermemory", reason: "Persistent memory across sessions" },
+    { tool: "repoprompt", reason: "Better context building for code generation" },
+    { tool: "beads", reason: "Task tracking that persists between sessions" },
+    { tool: "stagehand", reason: "AI-powered E2E testing" }
+  ];
+  for (let i3 = 0;i3 < genericRecs.length; i3++) {
+    const rec = genericRecs[i3];
+    console.log(`${BOLD2}${i3 + 1}. ${CYAN2}${rec.tool}${RESET2}`);
+    console.log(`   ${rec.reason}`);
+    consola.log("");
+  }
+}
+function getSourceIcon(source) {
+  switch (source) {
+    case "pain_point":
+      return `${YELLOW2}[pain point]${RESET2}`;
+    case "stack":
+      return `${GREEN2}[your stack]${RESET2}`;
+    case "trending":
+      return `${MAGENTA2}[trending]${RESET2}`;
+    case "community":
+      return `${DIM2}[community]${RESET2}`;
+    default:
+      return "";
+  }
+}
+async function showSkillsRecommendations(projectPath, autoInstall) {
+  console.log(`${BOLD2}${CYAN2}SKILLS.SH RECOMMENDATIONS${RESET2}`);
+  console.log(`${DIM2}Based on your workflow patterns${RESET2}`);
+  console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+  consola.log("");
+  const contextPath = join16(projectPath, ".nairon", "context.json");
+  let techStack = [];
+  let painPoints = [];
+  if (existsSync16(contextPath)) {
+    try {
+      const context = JSON.parse(readFileSync13(contextPath, "utf-8"));
+      techStack = context.techStack || [];
+      painPoints = context.painPoints || [];
+    } catch {}
+  }
+  const reportsDir = join16(projectPath, ".nairon", "reports");
+  let detectedIssues = [];
+  if (existsSync16(reportsDir)) {
+    try {
+      const files = __require("fs").readdirSync(reportsDir).filter((f3) => f3.endsWith(".md"));
+      if (files.length > 0) {
+        const latestReport = readFileSync13(join16(reportsDir, files[files.length - 1]), "utf-8");
+        if (latestReport.includes("Testing") && latestReport.includes("0/100")) {
+          detectedIssues.push("testing");
+        }
+        if (latestReport.includes("frustration") || latestReport.includes("Frustration")) {
+          detectedIssues.push("debugging");
+        }
+        if (latestReport.includes("Planning") && latestReport.match(/Planning.*[0-4]\d\/100/)) {
+          detectedIssues.push("planning");
+        }
+      }
+    } catch {}
+  }
+  if (painPoints.includes("testing"))
+    detectedIssues.push("testing");
+  if (painPoints.includes("context"))
+    detectedIssues.push("memory");
+  if (painPoints.includes("prompting"))
+    detectedIssues.push("planning");
+  const recommendations = [];
+  for (const tech of techStack) {
+    const key = tech.toLowerCase();
+    const skills = SKILLS_SH_MAPPINGS[key] || [];
+    for (const skill of skills) {
+      recommendations.push({
+        skill: skill.skill,
+        name: skill.name,
+        reason: skill.reason,
+        category: tech,
+        installs: skill.installs
+      });
+    }
+  }
+  for (const issue of detectedIssues) {
+    const skills = SKILLS_SH_MAPPINGS[issue] || [];
+    for (const skill of skills) {
+      if (!recommendations.some((r3) => r3.skill === skill.skill)) {
+        recommendations.push({
+          skill: skill.skill,
+          name: skill.name,
+          reason: skill.reason,
+          category: issue,
+          installs: skill.installs
+        });
+      }
+    }
+  }
+  if (recommendations.length < 3) {
+    const genericSkills = [
+      ...SKILLS_SH_MAPPINGS["frontend"] || [],
+      ...SKILLS_SH_MAPPINGS["brainstorming"] || [],
+      ...SKILLS_SH_MAPPINGS["debugging"] || []
+    ];
+    for (const skill of genericSkills) {
+      if (!recommendations.some((r3) => r3.skill === skill.skill)) {
+        recommendations.push({
+          skill: skill.skill,
+          name: skill.name,
+          reason: skill.reason,
+          category: "general",
+          installs: skill.installs
+        });
+      }
+    }
+  }
+  recommendations.sort((a2, b2) => (b2.installs || 0) - (a2.installs || 0));
+  const toShow = recommendations.slice(0, 5);
+  if (toShow.length === 0) {
+    console.log(`${DIM2}No skill recommendations at this time.${RESET2}`);
+    console.log(`${DIM2}Run 'nb onboard' to set up your project context.${RESET2}`);
+    return;
+  }
+  const toInstall = [];
+  for (let i3 = 0;i3 < toShow.length; i3++) {
+    const rec = toShow[i3];
+    const installsStr = rec.installs ? `${DIM2}${(rec.installs / 1000).toFixed(1)}K installs${RESET2}` : "";
+    console.log(`${BOLD2}${i3 + 1}. ${CYAN2}${rec.name}${RESET2} ${installsStr}`);
+    console.log(`   ${rec.reason}`);
+    console.log(`   ${DIM2}npx skills add ${rec.skill}${RESET2}`);
+    consola.log("");
+    toInstall.push(rec.skill);
+  }
+  if (autoInstall && toInstall.length > 0) {
+    console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+    console.log(`${YELLOW2}Installing ${toInstall.length} skills...${RESET2}`);
+    consola.log("");
+    for (const skill of toInstall) {
+      const skillName = skill.split("/").pop();
+      try {
+        console.log(`${DIM2}→ Installing ${skillName}...${RESET2}`);
+        execSync5(`npx skills add ${skill}`, { stdio: "inherit" });
+        console.log(`${GREEN2}✓${RESET2} Installed ${skillName}`);
+      } catch (err) {
+        console.log(`${RED}✗${RESET2} Failed to install ${skillName}`);
+      }
+      consola.log("");
+    }
+    console.log(`${GREEN2}Done!${RESET2} Skills are now available in your agent.`);
+  } else if (!autoInstall) {
+    console.log(`${DIM2}${"─".repeat(50)}${RESET2}`);
+    console.log(`${DIM2}Run ${CYAN2}nb recommend --install${RESET2}${DIM2} to auto-install these skills${RESET2}`);
+  }
+}
+
+// src/commands/upgrade.ts
+import { execSync as execSync6 } from "node:child_process";
+var CYAN3 = "\x1B[36m";
+var GREEN3 = "\x1B[32m";
+var YELLOW3 = "\x1B[33m";
+var DIM3 = "\x1B[2m";
+var BOLD3 = "\x1B[1m";
+var RESET3 = "\x1B[0m";
+var MAGENTA3 = "\x1B[35m";
+var CHANGELOG = [
+  {
+    version: "0.2.0",
+    date: "2026-02-14",
+    title: "Skills.sh Auto-Install",
+    highlights: [
+      "nb recommend --skills: Show skills.sh recommendations",
+      "nb recommend --install: Auto-install skills with one command",
+      "Maps pain points & tech stack to 50+ skills",
+      "Slack notifications on new releases"
+    ]
+  },
+  {
+    version: "0.1.0",
+    date: "2026-02-13",
+    title: "Nightcrawler & Recommendations",
+    highlights: [
+      "nb onboard - Set up project context for personalized recommendations",
+      "nb trending - See hot topics in AI dev tools community",
+      "nb recommend - Get personalized tool suggestions",
+      "Auto-recommendations after nb scan",
+      "Background X/Twitter scraper with hype filter",
+      "Cost-optimized scraping (~$35/month)"
+    ]
+  },
+  {
+    version: "0.0.40",
+    date: "2026-02-10",
+    title: "Frustration Detection & Smarter Reports",
+    highlights: [
+      "Detect frustration patterns in AI sessions",
+      "Improved report generation",
+      "Better token waste analysis"
+    ]
+  },
+  {
+    version: "0.0.34",
+    date: "2026-02-08",
+    title: "Accurate Token & Commit Tracking",
+    highlights: [
+      "Fixed token counting accuracy",
+      "Improved commit attribution",
+      "Better session correlation"
+    ]
+  },
+  {
+    version: "0.0.31",
+    date: "2026-02-08",
+    title: "Multi-Agent Support & Report Sharing",
+    highlights: [
+      "Support for multiple AI agents",
+      "Shareable reports with nb publish",
+      "Improved dashboard"
+    ]
+  },
+  {
+    version: "0.0.26",
+    date: "2026-02-07",
+    title: "Hackathon Reports & Publish Links",
+    highlights: [
+      "nb report for hackathon submissions",
+      "Publishable report links",
+      "SDLC phase analysis"
+    ]
+  },
+  {
+    version: "0.0.22",
+    date: "2026-02-07",
+    title: "Multi-Agent & Team Features",
+    highlights: [
+      "Team workflow support",
+      "Multi-agent session tracking",
+      "Improved cost analysis"
+    ]
+  },
+  {
+    version: "0.0.18",
+    date: "2026-02-07",
+    title: "CI/CD & Analytics",
+    highlights: [
+      "CI/CD integration support",
+      "Enhanced analytics dashboard",
+      "Badge system"
+    ]
+  }
+];
+var upgradeCommand = defineCommand2({
+  meta: {
+    name: "upgrade",
+    description: "Upgrade nairon-bench to the latest version and see what's new"
+  },
+  args: {
+    check: {
+      type: "boolean",
+      description: "Only check for updates without installing",
+      default: false
+    },
+    changelog: {
+      type: "boolean",
+      description: "Show full changelog",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const currentVersion = getCurrentVersion();
+    console.log();
+    console.log(`${BOLD3}${CYAN3}  nairon-bench upgrade${RESET3}`);
+    console.log(`${DIM3}  ${"─".repeat(40)}${RESET3}`);
+    console.log();
+    if (args.changelog) {
+      showFullChangelog();
+      return;
+    }
+    console.log(`${DIM3}  Checking for updates...${RESET3}`);
+    let latestVersion;
+    try {
+      latestVersion = execSync6("npm view nairon-bench version", { encoding: "utf-8" }).trim();
+    } catch {
+      console.log(`  ${YELLOW3}⚠${RESET3} Could not check npm registry`);
+      console.log(`  ${DIM3}Run 'bun upgrade -g nairon-bench' manually${RESET3}`);
+      return;
+    }
+    console.log();
+    console.log(`  ${DIM3}Current:${RESET3} ${currentVersion}`);
+    console.log(`  ${DIM3}Latest:${RESET3}  ${latestVersion}`);
+    console.log();
+    if (compareVersions(currentVersion, latestVersion) >= 0) {
+      console.log(`  ${GREEN3}✓${RESET3} You're on the latest version!`);
+      console.log();
+      console.log(`  ${DIM3}Run 'nb upgrade --changelog' to see past releases${RESET3}`);
+      return;
+    }
+    const newReleases = getNewReleases(currentVersion, latestVersion);
+    if (newReleases.length > 0) {
+      showWhatsNew(newReleases);
+    }
+    if (args.check) {
+      console.log();
+      console.log(`  ${DIM3}Run 'nb upgrade' to install${RESET3}`);
+      return;
+    }
+    console.log();
+    console.log(`${DIM3}  ${"─".repeat(40)}${RESET3}`);
+    console.log(`  ${CYAN3}↓${RESET3} Upgrading to ${GREEN3}v${latestVersion}${RESET3}...`);
+    console.log();
+    try {
+      try {
+        execSync6("bun upgrade -g nairon-bench", { stdio: "inherit" });
+      } catch {
+        execSync6("npm install -g nairon-bench@latest", { stdio: "inherit" });
+      }
+      console.log();
+      console.log(`  ${GREEN3}✓${RESET3} Upgraded to ${GREEN3}v${latestVersion}${RESET3}`);
+      console.log();
+      console.log(`  ${DIM3}Run 'nb doctor' to verify installation${RESET3}`);
+    } catch (err) {
+      console.log();
+      console.log(`  ${YELLOW3}⚠${RESET3} Upgrade failed`);
+      console.log(`  ${DIM3}Try running manually:${RESET3}`);
+      console.log(`  ${CYAN3}bun upgrade -g nairon-bench${RESET3}`);
+      console.log(`  ${DIM3}or${RESET3}`);
+      console.log(`  ${CYAN3}npm install -g nairon-bench@latest${RESET3}`);
+    }
+  }
+});
+function getCurrentVersion() {
+  try {
+    const output = execSync6("nb --version 2>/dev/null || nairon-bench --version 2>/dev/null", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = output.match(/v?(\d+\.\d+\.\d+)/);
+    return match ? match[1] : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareVersions(a2, b2) {
+  const partsA = a2.split(".").map(Number);
+  const partsB = b2.split(".").map(Number);
+  for (let i3 = 0;i3 < 3; i3++) {
+    const diff = (partsA[i3] || 0) - (partsB[i3] || 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function getNewReleases(currentVersion, latestVersion) {
+  return CHANGELOG.filter((entry) => {
+    return compareVersions(entry.version, currentVersion) > 0 && compareVersions(entry.version, latestVersion) <= 0;
+  });
+}
+function showWhatsNew(releases) {
+  console.log(`  ${BOLD3}${MAGENTA3}What's New${RESET3}`);
+  console.log();
+  for (const release of releases) {
+    const isMajor = release.version.endsWith(".0") && !release.version.startsWith("0.0.");
+    const isMinor = release.version.split(".")[1] !== "0" && release.version.endsWith(".0");
+    const versionColor = isMajor ? GREEN3 : isMinor ? CYAN3 : DIM3;
+    console.log(`  ${versionColor}${BOLD3}v${release.version}${RESET3} ${DIM3}(${release.date})${RESET3}`);
+    console.log(`  ${release.title}`);
+    console.log();
+    for (const highlight of release.highlights.slice(0, 4)) {
+      console.log(`    ${GREEN3}•${RESET3} ${highlight}`);
+    }
+    if (release.highlights.length > 4) {
+      console.log(`    ${DIM3}+ ${release.highlights.length - 4} more improvements${RESET3}`);
+    }
+    console.log();
+  }
+}
+function showFullChangelog() {
+  console.log(`  ${BOLD3}${MAGENTA3}Full Changelog${RESET3}`);
+  console.log();
+  for (const release of CHANGELOG) {
+    console.log(`  ${CYAN3}${BOLD3}v${release.version}${RESET3} ${DIM3}(${release.date})${RESET3}`);
+    console.log(`  ${release.title}`);
+    console.log();
+    for (const highlight of release.highlights) {
+      console.log(`    ${GREEN3}•${RESET3} ${highlight}`);
+    }
+    console.log();
+    console.log(`  ${DIM3}${"─".repeat(38)}${RESET3}`);
+    console.log();
+  }
+  console.log(`  ${DIM3}See full history at:${RESET3}`);
+  console.log(`  ${CYAN3}https://nairon.ai/changelog${RESET3}`);
+}
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.0.40",
+  version: "0.2.0",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -23677,52 +24871,52 @@ var package_default = {
 };
 
 // src/lib/mascot.ts
-var CYAN = "\x1B[36m";
+var CYAN4 = "\x1B[36m";
 var WHITE = "\x1B[97m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
-var RESET = "\x1B[0m";
+var DIM4 = "\x1B[2m";
+var BOLD4 = "\x1B[1m";
+var RESET4 = "\x1B[0m";
 function renderMascot(version2, cwd) {
   const projectName = cwd ? cwd.split("/").pop() || cwd : "";
-  const projectLine = projectName ? `   ${DIM}${projectName}${RESET}` : "";
+  const projectLine = projectName ? `   ${DIM4}${projectName}${RESET4}` : "";
   return `
-${WHITE}  ▗▄▄▄▄▄▄▄▄▖${RESET}
-${WHITE}  ▐${CYAN}█▀▀▀▀▀▀█${WHITE}▌${RESET}   ${BOLD}NBench${RESET} ${DIM}v${version2}${RESET}
-${WHITE}  ▐${CYAN}█ ${WHITE}▲${CYAN}    █${WHITE}▌${RESET}   ${DIM}Benchmark AI workflows${RESET}
-${WHITE}  ▐${CYAN}█▄▄▄▄▄▄█${WHITE}▌${RESET}${projectLine}
-${WHITE}  ▝▀▀▀▀▀▀▀▀▘${RESET}
+${WHITE}  ▗▄▄▄▄▄▄▄▄▖${RESET4}
+${WHITE}  ▐${CYAN4}█▀▀▀▀▀▀█${WHITE}▌${RESET4}   ${BOLD4}NBench${RESET4} ${DIM4}v${version2}${RESET4}
+${WHITE}  ▐${CYAN4}█ ${WHITE}▲${CYAN4}    █${WHITE}▌${RESET4}   ${DIM4}Benchmark AI workflows${RESET4}
+${WHITE}  ▐${CYAN4}█▄▄▄▄▄▄█${WHITE}▌${RESET4}${projectLine}
+${WHITE}  ▝▀▀▀▀▀▀▀▀▘${RESET4}
 `;
 }
 
 // src/index.ts
 var VERSION = package_default.version;
-var YELLOW = "\x1B[33m";
-var DIM2 = "\x1B[2m";
-var BOLD2 = "\x1B[1m";
-var RESET2 = "\x1B[0m";
+var YELLOW4 = "\x1B[33m";
+var DIM5 = "\x1B[2m";
+var BOLD5 = "\x1B[1m";
+var RESET5 = "\x1B[0m";
 function showBanner() {
   const log = (msg) => process.stdout.write(msg + `
 `);
-  const GREEN = "\x1B[32m";
-  const CYAN2 = "\x1B[36m";
+  const GREEN4 = "\x1B[32m";
+  const CYAN5 = "\x1B[36m";
   log(renderMascot(VERSION, process.cwd()));
-  log(`${YELLOW}\u2501\u2501\u2501 Quick Start \u2501\u2501\u2501${RESET2}`);
+  log(`${YELLOW4}\u2501\u2501\u2501 Quick Start \u2501\u2501\u2501${RESET5}`);
   log("");
-  log(`  ${GREEN}1.${RESET2} ${BOLD2}nb init${RESET2}              Set up your profile (first time only)`);
-  log(`  ${GREEN}2.${RESET2} ${BOLD2}nb scan${RESET2}              Analyze your AI coding sessions`);
-  log(`  ${GREEN}3.${RESET2} ${BOLD2}nb report --publish${RESET2}  Generate & share your report`);
+  log(`  ${GREEN4}1.${RESET5} ${BOLD5}nb init${RESET5}              Set up your profile (first time only)`);
+  log(`  ${GREEN4}2.${RESET5} ${BOLD5}nb scan${RESET5}              Analyze your AI coding sessions`);
+  log(`  ${GREEN4}3.${RESET5} ${BOLD5}nb report --publish${RESET5}  Generate & share your report`);
   log("");
-  log(`${DIM2}\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510${RESET2}`);
-  log(`${DIM2}\u2502${RESET2}  ${CYAN2}How often?${RESET2}                                      ${DIM2}\u2502${RESET2}`);
-  log(`${DIM2}\u2502${RESET2}  \u2022 Run ${BOLD2}nb scan${RESET2} after coding sessions            ${DIM2}\u2502${RESET2}`);
-  log(`${DIM2}\u2502${RESET2}  \u2022 Run ${BOLD2}nb report${RESET2} weekly to track progress       ${DIM2}\u2502${RESET2}`);
-  log(`${DIM2}\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518${RESET2}`);
+  log(`${DIM5}\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510${RESET5}`);
+  log(`${DIM5}\u2502${RESET5}  ${CYAN5}How often?${RESET5}                                      ${DIM5}\u2502${RESET5}`);
+  log(`${DIM5}\u2502${RESET5}  \u2022 Run ${BOLD5}nb scan${RESET5} after coding sessions            ${DIM5}\u2502${RESET5}`);
+  log(`${DIM5}\u2502${RESET5}  \u2022 Run ${BOLD5}nb report${RESET5} weekly to track progress       ${DIM5}\u2502${RESET5}`);
+  log(`${DIM5}\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518${RESET5}`);
   log("");
-  log(`${DIM2}Run ${BOLD2}nb --help${RESET2}${DIM2} for all commands${RESET2}`);
+  log(`${DIM5}Run ${BOLD5}nb --help${RESET5}${DIM5} for all commands${RESET5}`);
   log("");
 }
 var args = process.argv.slice(2);
-var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export", "pr", "badges", "cache", "setup"];
+var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export", "pr", "badges", "cache", "setup", "onboard", "trending", "recommend"];
 var hasSubcommand = args.some((arg) => subcommands.includes(arg));
 var hasHelp = args.includes("--help") || args.includes("-h");
 var hasVersion = args.includes("--version");
@@ -23751,7 +24945,11 @@ if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
       pr: prCommand,
       badges: badgesCommand,
       cache: cacheCommand,
-      setup: setupCommand
+      setup: setupCommand,
+      onboard: onboardCommand,
+      trending: trendingCommand,
+      recommend: recommendCommand,
+      upgrade: upgradeCommand
     }
   });
   runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nairon-bench",
-  "version": "0.0.40",
+  "version": "0.2.0",
   "description": "AI workflow benchmarking CLI",
   "type": "module",
   "bin": {