nairon-bench 0.3.11 → 0.3.13

package/dist/index.js

@@ -10767,7 +10767,7 @@ function getTechStackSpecificRecommendations(projectContext) {
       description: "Vercel's React and Next.js patterns for your stack",
       impact: "medium",
       type: "skill",
-      installCommand: "npx skills add vercel/react-best-practices"
+      installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes"
     });
   }
   if (database2?.includes("convex")) {
@@ -10985,11 +10985,10 @@ function analyzePlanning2(agents, git, projectDir, analysis, projectContext) {
     strengths.push("Has planning skill installed");
   } else {
     recommendations.push({
-      title: "Install Writing Plans skill",
-      description: "Structured planning before implementation",
+      title: "Add AGENTS.md for planning guidance",
+      description: "Create an AGENTS.md file with project-specific planning instructions",
       impact: "medium",
-      type: "skill",
-      installCommand: "npx skills add obra/superpowers/writing-plans"
+      type: "config"
     });
   }
   if (agents && agents.sessions.length > 0) {
@@ -11282,11 +11281,11 @@ function analyzeReview2(agents, git, tests, projectDir, analysis, projectContext
     strengths.push("TDD workflow skill installed");
   } else {
     recommendations.push({
-      title: "Install TDD skill",
-      description: "Test-driven development workflow - write tests first",
-      impact: "medium",
-      type: "skill",
-      installCommand: "npx skills add obra/superpowers/test-driven-development"
+      title: "Add testing framework",
+      description: "Install Vitest or Jest for test-driven development",
+      impact: "high",
+      type: "library",
+      installCommand: "bun add -D vitest"
     });
   }
   const hasLinting = existsSync6(join6(projectDir, ".eslintrc.js")) || existsSync6(join6(projectDir, ".eslintrc.json")) || existsSync6(join6(projectDir, "eslint.config.js")) || existsSync6(join6(projectDir, "biome.json"));
@@ -11860,19 +11859,11 @@ Describe your project structure here.
       selected: true
     },
     {
-      id: "tdd-skill",
-      name: "TDD Skill",
-      type: "skill",
-      description: "Test-driven development workflow",
-      installCommand: "npx skills add obra/superpowers/test-driven-development",
-      selected: true
-    },
-    {
-      id: "debugging-skill",
-      name: "Debugging Skill",
-      type: "skill",
-      description: "Systematic debugging approach",
-      installCommand: "npx skills add obra/superpowers/systematic-debugging",
+      id: "vitest",
+      name: "Vitest",
+      type: "library",
+      description: "Fast unit testing framework",
+      installCommand: "bun add -D vitest",
       selected: true
     }
   ]
@@ -21370,12 +21361,651 @@ import { existsSync as existsSync12 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { join as join12 } from "node:path";
 init_client();
+
+// src/lib/recommendations-db.ts
+var MCP_SERVERS = [
+  {
+    id: "context7",
+    name: "Context7",
+    type: "mcp",
+    description: "Live documentation for any library - reduces API hallucinations by 40%+",
+    installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
+    phases: ["requirements", "implementation"],
+    impact: "high",
+    detectionKey: "context7",
+    website: "https://context7.com",
+    badge: "Essential",
+    agents: {
+      "claude-code": { installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http" },
+      opencode: { installCommand: "Add to ~/.config/opencode/config.json mcpServers" }
+    }
+  },
+  {
+    id: "supermemory",
+    name: "Supermemory",
+    type: "mcp",
+    description: "Persistent memory across sessions - never re-explain context",
+    installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
+    phases: ["requirements", "implementation"],
+    impact: "high",
+    detectionKey: "supermemory",
+    website: "https://supermemory.ai",
+    badge: "Essential",
+    agents: {
+      "claude-code": { installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest" }
+    }
+  },
+  {
+    id: "nia",
+    name: "Nia",
+    type: "mcp",
+    description: "Index and search external codebases and documentation",
+    installCommand: "pipx run --no-cache nia-mcp-server",
+    phases: ["requirements"],
+    impact: "medium",
+    detectionKey: "nia",
+    website: "https://trynia.ai"
+  },
+  {
+    id: "greptile",
+    name: "Greptile",
+    type: "mcp",
+    description: "AI-powered code review and PR analysis",
+    installCommand: "claude mcp add greptile -- npx -y @greptile/mcp",
+    phases: ["review"],
+    impact: "high",
+    detectionKey: "greptile",
+    website: "https://www.greptile.com",
+    badge: "Recommended"
+  },
+  {
+    id: "agent-browser",
+    name: "Agent Browser",
+    type: "mcp",
+    description: "Live end-to-end browser testing and automation",
+    installCommand: "claude mcp add agent-browser -- npx -y agent-browser-mcp",
+    phases: ["review"],
+    impact: "high",
+    detectionKey: "agent-browser",
+    website: "https://agent-browser.dev",
+    badge: "Recommended"
+  },
+  {
+    id: "playwright-mcp",
+    name: "Playwright MCP",
+    type: "mcp",
+    description: "Browser automation for E2E testing and web scraping",
+    installCommand: "claude mcp add playwright -- npx -y @anthropic/playwright-mcp",
+    phases: ["review"],
+    impact: "medium",
+    detectionKey: "playwright",
+    website: "https://playwright.dev"
+  },
+  {
+    id: "github-mcp",
+    name: "GitHub MCP",
+    type: "mcp",
+    description: "GitHub integration for PRs, issues, and repo management",
+    installCommand: "claude mcp add github -- npx -y @anthropic/github-mcp",
+    phases: ["planning", "review"],
+    impact: "medium",
+    detectionKey: "github"
+  }
+];
+var PLUGINS = [
+  {
+    id: "beads",
+    name: "Beads",
+    type: "plugin",
+    description: "Lightweight issue tracking in git - survives context compaction",
+    installCommand: "bun add -g beads && bd init",
+    phases: ["planning"],
+    impact: "high",
+    detectionKey: "beads",
+    website: "https://github.com/steveyegge/beads",
+    badge: "Recommended"
+  },
+  {
+    id: "linear",
+    name: "Linear",
+    type: "plugin",
+    description: "Sync with Linear issues for team collaboration",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://linear.app"
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    type: "plugin",
+    description: "Team notifications and updates",
+    phases: ["review"],
+    impact: "low",
+    website: "https://slack.com"
+  }
+];
+var SKILLS = [
+  {
+    id: "tdd-skill",
+    name: "Test-Driven Development",
+    type: "skill",
+    description: "Write tests first, then implement - reduces bugs by 40%",
+    installCommand: "npx skills add obra/superpowers@test-driven-development --yes",
+    phases: ["review"],
+    impact: "high",
+    website: "https://skills.sh"
+  },
+  {
+    id: "debugging-skill",
+    name: "Systematic Debugging",
+    type: "skill",
+    description: "Structured approach to finding and fixing bugs",
+    installCommand: "npx skills add obra/superpowers@systematic-debugging --yes",
+    phases: ["implementation", "review"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "planning-skill",
+    name: "Writing Plans",
+    type: "skill",
+    description: "Structured planning before implementation",
+    installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "code-review-skill",
+    name: "Code Review",
+    type: "skill",
+    description: "Thorough code review checklist and workflow",
+    installCommand: "npx skills add obra/superpowers@requesting-code-review --yes",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "react-skill",
+    name: "React Best Practices",
+    type: "skill",
+    description: "Vercel's React and Next.js patterns",
+    installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "remotion-skill",
+    name: "Remotion",
+    type: "skill",
+    description: "Video creation with React",
+    installCommand: "npx skills add remotion-dev/skills@remotion-best-practices --yes",
+    phases: ["implementation"],
+    impact: "low",
+    website: "https://skills.sh"
+  },
+  {
+    id: "frontend-design-skill",
+    name: "Frontend Design",
+    type: "skill",
+    description: "Anthropic's frontend design patterns",
+    installCommand: "npx skills add anthropics/skills@frontend-design --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "web-design-skill",
+    name: "Web Design Guidelines",
+    type: "skill",
+    description: "Vercel's web design guidelines",
+    installCommand: "npx skills add vercel-labs/agent-skills@web-design-guidelines --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  }
+];
+var LIBRARIES = [
+  {
+    id: "vitest",
+    name: "Vitest",
+    type: "library",
+    description: "Fast unit testing framework for TypeScript/JavaScript",
+    installCommand: "bun add -D vitest",
+    phases: ["review"],
+    impact: "high",
+    website: "https://vitest.dev"
+  },
+  {
+    id: "playwright",
+    name: "Playwright",
+    type: "library",
+    description: "E2E testing framework for web applications",
+    installCommand: "bun add -D playwright @playwright/test",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://playwright.dev"
+  },
+  {
+    id: "biome",
+    name: "Biome",
+    type: "library",
+    description: "Fast linter and formatter (replaces ESLint + Prettier)",
+    installCommand: "bun add -D @biomejs/biome && bunx biome init",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://biomejs.dev"
+  }
+];
+var CONFIG_FILES = [
+  {
+    id: "claude-md",
+    name: "CLAUDE.md",
+    type: "config",
+    description: "Project-specific instructions for AI - commands, conventions, architecture",
+    configPath: "CLAUDE.md",
+    configContent: `# Project Instructions
+
+## Build & Test Commands
+\`\`\`bash
+bun test           # Run tests
+bun run build      # Build project
+bun run lint       # Run linter
+\`\`\`
+
+## Architecture
+Describe your project structure here.
+
+## Conventions
+- Use TypeScript
+- Write tests for new features
+- Use conventional commits
+`,
+    phases: ["requirements"],
+    impact: "high"
+  },
+  {
+    id: "agents-md",
+    name: "AGENTS.md",
+    type: "config",
+    description: "Agent-specific instructions and workflows",
+    configPath: "AGENTS.md",
+    configContent: `# Agent Instructions
+
+## Package Manager
+This project uses **bun** exclusively.
+
+## Workflow
+1. Read existing code before making changes
+2. Write tests for new features
+3. Run \`bun test\` before committing
+`,
+    phases: ["requirements", "planning"],
+    impact: "medium"
+  }
+];
+var WORKFLOW_TOOLS = [
+  {
+    id: "granola",
+    name: "Granola",
+    type: "tool",
+    description: "AI meeting notes and requirements capture",
+    phases: ["requirements"],
+    impact: "medium",
+    website: "https://www.granola.ai/"
+  },
+  {
+    id: "repoprompt",
+    name: "RepoPrompt",
+    type: "tool",
+    description: "Generate AI prompts from your codebase",
+    phases: ["requirements"],
+    impact: "medium",
+    website: "https://repoprompt.com"
+  },
+  {
+    id: "figma",
+    name: "Figma / v0",
+    type: "tool",
+    description: "Design tools for UI/UX planning",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://figma.com"
+  }
+];
+var ALL_RECOMMENDATIONS = [
+  ...MCP_SERVERS,
+  ...PLUGINS,
+  ...SKILLS,
+  ...LIBRARIES,
+  ...CONFIG_FILES,
+  ...WORKFLOW_TOOLS
+];
+var INSTALLABLE_RECOMMENDATIONS = ALL_RECOMMENDATIONS.filter((r3) => r3.installCommand || r3.configPath);
+if (false) {}
+
+// src/lib/verify-recommendations.ts
+function validateSkillFormat(command) {
+  if (!command.match(/^(npx|bunx)\s+skills\s+add\s+/)) {
+    return { valid: false, message: "Must start with 'npx skills add' or 'bunx skills add'" };
+  }
+  const match = command.match(/skills\s+add\s+([^\s]+)/);
+  if (!match) {
+    return { valid: false, message: "Could not extract skill path" };
+  }
+  const skillPath = match[1] ?? "";
+  if (!skillPath.includes("@")) {
+    return {
+      valid: false,
+      message: `Invalid format '${skillPath}'. Must use @ separator: owner/repo@skill-name`
+    };
+  }
+  const skillMatch = skillPath.match(/^([^\/]+)\/([^@]+)@([^\/\s]+)$/);
+  if (!skillMatch) {
+    return {
+      valid: false,
+      message: `Invalid skill path '${skillPath}'. Expected: owner/repo@skill-name`
+    };
+  }
+  if (!command.includes("--yes")) {
+    return {
+      valid: false,
+      message: "Missing --yes flag for non-interactive installation"
+    };
+  }
+  return { valid: true, message: "Valid skills.sh format" };
+}
+function validateMCPFormat(command) {
+  if (command.startsWith("claude mcp add")) {
+    if (command.includes("-- npx") || command.includes("--transport")) {
+      return { valid: true, message: "Valid Claude MCP format" };
+    }
+    return { valid: false, message: "MCP command should have '-- npx' or '--transport' pattern" };
+  }
+  if (command.startsWith("pipx run")) {
+    return { valid: true, message: "Valid pipx MCP format" };
+  }
+  if (command.includes("config") || command.includes("mcpServers")) {
+    return { valid: true, message: "Manual configuration instruction" };
+  }
+  return { valid: false, message: "Unknown MCP install format" };
+}
+function validatePackageFormat(command) {
+  if (command.match(/^bun\s+add\s+(-[dDgG]\s+)?[@\w\/-]+/)) {
+    return { valid: true, message: "Valid bun add format" };
+  }
+  if (command.match(/^npm\s+(install|i)\s+(-[dDgG]\s+)?[@\w\/-]+/)) {
+    return { valid: true, message: "Valid npm install format" };
+  }
+  if (command.match(/^(bunx|npx)\s+/)) {
+    return { valid: true, message: "Valid bunx/npx format" };
+  }
+  return { valid: false, message: "Unknown package install format" };
+}
+async function checkNpmPackageExists(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5000)
+    });
+    if (response.ok) {
+      return { exists: true, message: "Package exists on npm" };
+    }
+    return { exists: false, message: `Package not found on npm (${response.status})` };
+  } catch (error2) {
+    return { exists: false, message: `Could not verify: ${error2 instanceof Error ? error2.message : String(error2)}` };
+  }
+}
+async function checkGitHubRepoExists(owner, repo) {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5000)
+    });
+    if (response.ok) {
+      return { exists: true, message: "GitHub repo exists" };
+    }
+    if (response.status === 404) {
+      return { exists: false, message: `GitHub repo ${owner}/${repo} not found` };
+    }
+    return { exists: false, message: `GitHub API error (${response.status})` };
+  } catch (error2) {
+    return { exists: false, message: `Could not verify: ${error2 instanceof Error ? error2.message : String(error2)}` };
+  }
+}
+function verifyRecommendation(rec) {
+  const base = {
+    id: rec.id,
+    name: rec.name,
+    type: rec.type,
+    installCommand: rec.installCommand
+  };
+  if (!rec.installCommand && !rec.configPath) {
+    return { ...base, status: "skipped", message: "No install command (informational only)" };
+  }
+  if (rec.type === "config" && rec.configPath) {
+    return { ...base, status: "valid", message: `Config file: ${rec.configPath}` };
+  }
+  if (!rec.installCommand) {
+    return { ...base, status: "skipped", message: "No install command" };
+  }
+  switch (rec.type) {
+    case "skill": {
+      const result = validateSkillFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    case "mcp": {
+      const result = validateMCPFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    case "library":
+    case "plugin": {
+      const result = validatePackageFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    default:
+      return { ...base, status: "warning", message: `Unknown type: ${rec.type}` };
+  }
+}
+function verifyAllRecommendations() {
+  const results = [];
+  for (const rec of ALL_RECOMMENDATIONS) {
+    results.push(verifyRecommendation(rec));
+  }
+  const valid = results.filter((r3) => r3.status === "valid").length;
+  const invalid = results.filter((r3) => r3.status === "invalid").length;
+  const warnings = results.filter((r3) => r3.status === "warning").length;
+  const skipped = results.filter((r3) => r3.status === "skipped").length;
+  return {
+    total: results.length,
+    valid,
+    invalid,
+    warnings,
+    skipped,
+    results
+  };
+}
+async function verifyRecommendationsThorough() {
+  const basicResults = verifyAllRecommendations();
+  const enhancedResults = [];
+  for (const result of basicResults.results) {
+    if (result.status === "invalid" || result.status === "skipped") {
+      enhancedResults.push(result);
+      continue;
+    }
+    if (result.installCommand?.includes("skills add")) {
+      const match = result.installCommand.match(/skills\s+add\s+([^\/]+)\/([^@]+)@/);
+      if (match && match[1] && match[2]) {
+        const owner = match[1];
+        const repo = match[2];
+        const check = await checkGitHubRepoExists(owner, repo);
+        if (!check.exists) {
+          enhancedResults.push({
+            ...result,
+            status: "invalid",
+            message: check.message
+          });
+          continue;
+        }
+      }
+    }
+    if (result.installCommand?.match(/npx\s+-y\s+@?[\w\/-]+/)) {
+      const match = result.installCommand.match(/npx\s+-y\s+(@?[\w\/-]+)/);
+      if (match && match[1]) {
+        const packageName = match[1];
+        const check = await checkNpmPackageExists(packageName);
+        if (!check.exists) {
+          enhancedResults.push({
+            ...result,
+            status: "warning",
+            message: check.message
+          });
+          continue;
+        }
+      }
+    }
+    enhancedResults.push(result);
+  }
+  const valid = enhancedResults.filter((r3) => r3.status === "valid").length;
+  const invalid = enhancedResults.filter((r3) => r3.status === "invalid").length;
+  const warnings = enhancedResults.filter((r3) => r3.status === "warning").length;
+  const skipped = enhancedResults.filter((r3) => r3.status === "skipped").length;
+  return {
+    total: enhancedResults.length,
+    valid,
+    invalid,
+    warnings,
+    skipped,
+    results: enhancedResults
+  };
+}
+function printVerificationResults(summary, verbose = false) {
+  console.log(`
+═══════════════════════════════════════════════════════════════`);
+  console.log("  RECOMMENDATION VERIFICATION REPORT");
+  console.log(`═══════════════════════════════════════════════════════════════
+`);
+  const invalid = summary.results.filter((r3) => r3.status === "invalid");
+  if (invalid.length > 0) {
+    console.log(`❌ INVALID RECOMMENDATIONS:
+`);
+    for (const r3 of invalid) {
+      console.log(`  ${r3.name} (${r3.type})`);
+      console.log(`    ID: ${r3.id}`);
+      console.log(`    Issue: ${r3.message}`);
+      if (r3.installCommand) {
+        console.log(`    Command: ${r3.installCommand}`);
+      }
+      console.log();
+    }
+  }
+  const warnings = summary.results.filter((r3) => r3.status === "warning");
+  if (warnings.length > 0) {
+    console.log(`⚠️  WARNINGS:
+`);
+    for (const r3 of warnings) {
+      console.log(`  ${r3.name}: ${r3.message}`);
+    }
+    console.log();
+  }
+  if (verbose) {
+    const valid = summary.results.filter((r3) => r3.status === "valid");
+    if (valid.length > 0) {
+      console.log(`✓ VALID RECOMMENDATIONS:
+`);
+      for (const r3 of valid) {
+        console.log(`  ${r3.name} (${r3.type}): ${r3.message}`);
+      }
+      console.log();
+    }
+  }
+  console.log("───────────────────────────────────────────────────────────────");
+  console.log(`  Total: ${summary.total}`);
+  console.log(`  ✓ Valid: ${summary.valid}`);
+  console.log(`  ❌ Invalid: ${summary.invalid}`);
+  console.log(`  ⚠️  Warnings: ${summary.warnings}`);
+  console.log(`  ○ Skipped: ${summary.skipped}`);
+  console.log(`───────────────────────────────────────────────────────────────
+`);
+  if (summary.invalid > 0) {
+    console.log(`❌ VERIFICATION FAILED - Fix invalid recommendations before release!
+`);
+  } else if (summary.warnings > 0) {
+    console.log(`⚠️  VERIFICATION PASSED WITH WARNINGS
+`);
+  } else {
+    console.log(`✓ ALL RECOMMENDATIONS VERIFIED
+`);
+  }
+}
+
+// src/commands/doctor.ts
 var doctorCommand = defineCommand2({
   meta: {
     name: "doctor",
     description: "Check tool detection, data sources, and connectivity health"
   },
-  async run() {
+  args: {
+    "verify-recommendations": {
+      type: "boolean",
+      description: "Verify all recommendations in the database are valid",
+      alias: "verify",
+      default: false
+    },
+    thorough: {
+      type: "boolean",
+      description: "Run thorough verification with network checks",
+      alias: "t",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show all results including valid recommendations",
+      alias: "v",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (args["verify-recommendations"]) {
+      console.log();
+      console.log(colors2.bold(colors2.primary("  NaironAI Recommendation Verifier")));
+      console.log(colors2.dim(`  Validating all recommendation install commands...
+`));
+      const spinner2 = createSpinner("Verifying recommendations...");
+      spinner2.start();
+      let summary;
+      if (args.thorough) {
+        spinner2.text = "Verifying recommendations (thorough mode with network checks)...";
+        summary = await verifyRecommendationsThorough();
+      } else {
+        summary = verifyAllRecommendations();
+      }
+      if (summary.invalid > 0) {
+        spinner2.fail(`Found ${summary.invalid} invalid recommendation(s)`);
+      } else if (summary.warnings > 0) {
+        spinner2.warn(`Verification passed with ${summary.warnings} warning(s)`);
+      } else {
+        spinner2.succeed("All recommendations verified");
+      }
+      printVerificationResults(summary, args.verbose);
+      if (summary.invalid > 0) {
+        process.exit(1);
+      }
+      return;
+    }
     console.log();
     console.log(colors2.bold(colors2.primary("  NaironAI Doctor")));
     console.log(colors2.dim(`  Checking system health...
@@ -22013,6 +22643,25 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    version: "0.3.13",
+    date: "2026-02-14",
+    title: "Reliable Recommendations",
+    highlights: [
+      "Fixed skills.sh format - skills now install correctly",
+      "New: nb doctor --verify-recommendations to validate install commands"
+    ]
+  },
+  {
+    version: "0.3.12",
+    date: "2026-02-14",
+    title: "Fixed Skill Recommendations",
+    highlights: [
+      "Removed non-existent skill recommendations",
+      "Replaced with real, installable tools (Vitest, etc.)",
+      "Skills installation now foolproof"
+    ]
+  },
   {
     version: "0.3.11",
     date: "2026-02-14",
@@ -22402,7 +23051,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.3.11",
+  version: "0.3.13",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -22434,8 +23083,9 @@ var package_default = {
     "build:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile=dist/nb-linux-arm64 src/index.ts",
     "build:windows-x64": "bun build --compile --target=bun-windows-x64 --outfile=dist/nb-windows-x64.exe src/index.ts",
     typecheck: "tsc --noEmit",
-    test: "bun test",
-    "test:e2e": "bun test --test-name-pattern e2e",
+    test: "vitest run",
+    "test:e2e": "vitest run tests/e2e/",
+    "test:watch": "vitest",
     clean: "rm -rf dist",
     prepublishOnly: "bun run build"
   },
@@ -24926,7 +25576,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.3.11",
+  version: "0.3.13",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -24958,8 +25608,9 @@ var package_default2 = {
     "build:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile=dist/nb-linux-arm64 src/index.ts",
     "build:windows-x64": "bun build --compile --target=bun-windows-x64 --outfile=dist/nb-windows-x64.exe src/index.ts",
     typecheck: "tsc --noEmit",
-    test: "bun test",
-    "test:e2e": "bun test --test-name-pattern e2e",
+    test: "vitest run",
+    "test:e2e": "vitest run tests/e2e/",
+    "test:watch": "vitest",
     clean: "rm -rf dist",
     prepublishOnly: "bun run build"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nairon-bench",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "AI workflow benchmarking CLI",
   "type": "module",
   "bin": {
@@ -32,8 +32,9 @@
     "build:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile=dist/nb-linux-arm64 src/index.ts",
     "build:windows-x64": "bun build --compile --target=bun-windows-x64 --outfile=dist/nb-windows-x64.exe src/index.ts",
     "typecheck": "tsc --noEmit",
-    "test": "bun test",
-    "test:e2e": "bun test --test-name-pattern e2e",
+    "test": "vitest run",
+    "test:e2e": "vitest run tests/e2e/",
+    "test:watch": "vitest",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build"
   },