nairon-bench 0.0.19 → 0.0.20

package/dist/index.js

@@ -16954,6 +16954,476 @@ function generateCSV(data) {
 `);
 }
 
+// src/commands/pr.ts
+import { execSync as execSync2 } from "node:child_process";
+var prCommand = defineCommand2({
+  meta: {
+    name: "pr",
+    description: "Analyze AI usage in a pull request"
+  },
+  args: {
+    pr: {
+      type: "positional",
+      description: "PR number or URL (defaults to current branch's PR)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const jsonOutput = args.json;
+    if (!jsonOutput) {
+      console.log();
+      console.log(colors2.bold(colors2.primary("  PR AI Analysis")));
+      console.log(colors2.dim("  " + "─".repeat(40)));
+      console.log();
+    }
+    const spinner = jsonOutput ? null : createSpinner("Analyzing PR...");
+    if (spinner)
+      spinner.start();
+    try {
+      const prInfo = await getPRInfo(args.pr);
+      if (!prInfo) {
+        if (spinner)
+          spinner.fail("Could not find PR");
+        if (!jsonOutput) {
+          console.log(`  ${icons.error} No PR found. Provide a PR number or run from a branch with an open PR.`);
+        }
+        return;
+      }
+      if (spinner)
+        spinner.succeed(`Found PR #${prInfo.number}`);
+      const commits = await getPRCommits(prInfo.number);
+      const prStart = new Date(prInfo.createdAt);
+      const prEnd = prInfo.mergedAt ? new Date(prInfo.mergedAt) : new Date;
+      const sessions = await collectAgentSessions(prStart);
+      const prSessions = sessions?.sessions.filter((s2) => {
+        const sessionStart = new Date(s2.startedAt);
+        return sessionStart >= prStart && sessionStart <= prEnd;
+      }) || [];
+      const totalTokens = prSessions.reduce((sum, s2) => sum + s2.totalTokens, 0);
+      const totalCost = prSessions.reduce((sum, s2) => sum + s2.costUsd, 0);
+      const totalDuration = prSessions.reduce((sum, s2) => sum + s2.durationMinutes, 0);
+      const wastedTokens = prSessions.reduce((sum, s2) => sum + s2.patterns.reduce((ps, p) => ps + p.estimatedWastedTokens, 0), 0);
+      const modelUsage = {};
+      for (const session of prSessions) {
+        if (session.model) {
+          modelUsage[session.model] = (modelUsage[session.model] || 0) + 1;
+        }
+      }
+      const frustrationCount = prSessions.reduce((sum, s2) => sum + s2.patterns.filter((p) => p.type !== "smooth_flow").reduce((ps, p) => ps + p.count, 0), 0);
+      const result = {
+        pr: {
+          number: prInfo.number,
+          title: prInfo.title,
+          author: prInfo.author,
+          createdAt: prInfo.createdAt,
+          mergedAt: prInfo.mergedAt,
+          commits: commits.length,
+          additions: prInfo.additions,
+          deletions: prInfo.deletions
+        },
+        aiUsage: {
+          sessions: prSessions.length,
+          totalTokens,
+          totalCost: Math.round(totalCost * 100) / 100,
+          durationMinutes: totalDuration,
+          wastedTokens,
+          wastePercentage: totalTokens > 0 ? Math.round(wastedTokens / totalTokens * 100) : 0,
+          frustrationEvents: frustrationCount,
+          modelUsage
+        },
+        efficiency: {
+          tokensPerCommit: commits.length > 0 ? Math.round(totalTokens / commits.length) : 0,
+          tokensPerLine: prInfo.additions + prInfo.deletions > 0 ? Math.round(totalTokens / (prInfo.additions + prInfo.deletions)) : 0,
+          costPerCommit: commits.length > 0 ? Math.round(totalCost / commits.length * 100) / 100 : 0
+        }
+      };
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      console.log();
+      console.log(`  ${colors2.bold("PR Details")}`);
+      console.log(colors2.dim("  " + "─".repeat(40)));
+      console.log(`  ${colors2.dim("Number:")} #${prInfo.number}`);
+      console.log(`  ${colors2.dim("Title:")} ${prInfo.title.slice(0, 50)}${prInfo.title.length > 50 ? "..." : ""}`);
+      console.log(`  ${colors2.dim("Author:")} @${prInfo.author}`);
+      console.log(`  ${colors2.dim("Commits:")} ${commits.length}`);
+      console.log(`  ${colors2.dim("Changes:")} ${colors2.success(`+${prInfo.additions}`)} ${colors2.error(`-${prInfo.deletions}`)}`);
+      console.log();
+      console.log(`  ${colors2.bold("AI Usage During PR")}`);
+      console.log(colors2.dim("  " + "─".repeat(40)));
+      console.log(`  ${colors2.dim("Sessions:")} ${prSessions.length}`);
+      console.log(`  ${colors2.dim("Tokens:")} ${formatNumber(totalTokens)}`);
+      console.log(`  ${colors2.dim("Cost:")} ${colors2.success(`$${totalCost.toFixed(2)}`)}`);
+      console.log(`  ${colors2.dim("Duration:")} ${totalDuration} minutes`);
+      if (wastedTokens > 0) {
+        const wastePercent = Math.round(wastedTokens / totalTokens * 100);
+        console.log(`  ${colors2.dim("Wasted:")} ${colors2.error(`${formatNumber(wastedTokens)} tokens (${wastePercent}%)`)}`);
+      }
+      if (frustrationCount > 0) {
+        console.log(`  ${colors2.dim("Frustration events:")} ${colors2.warning(frustrationCount.toString())}`);
+      }
+      console.log();
+      console.log(`  ${colors2.bold("Efficiency")}`);
+      console.log(colors2.dim("  " + "─".repeat(40)));
+      console.log(`  ${colors2.dim("Tokens/commit:")} ${formatNumber(result.efficiency.tokensPerCommit)}`);
+      console.log(`  ${colors2.dim("Tokens/line:")} ${result.efficiency.tokensPerLine}`);
+      console.log(`  ${colors2.dim("Cost/commit:")} $${result.efficiency.costPerCommit.toFixed(2)}`);
+      console.log();
+      if (Object.keys(modelUsage).length > 0) {
+        console.log(`  ${colors2.bold("Models Used")}`);
+        console.log(colors2.dim("  " + "─".repeat(40)));
+        for (const [model, count] of Object.entries(modelUsage).sort((a2, b2) => b2[1] - a2[1])) {
+          const shortModel = model.length > 25 ? model.slice(0, 22) + "..." : model;
+          console.log(`  ${colors2.dim(shortModel.padEnd(25))} ${count} sessions`);
+        }
+        console.log();
+      }
+    } catch (error2) {
+      if (spinner)
+        spinner.fail("Analysis failed");
+      if (!jsonOutput) {
+        console.log(`  ${icons.error} ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+      }
+    }
+  }
+});
+async function getPRInfo(prArg) {
+  try {
+    let prNumber;
+    if (prArg) {
+      const match = prArg.match(/\/pull\/(\d+)/);
+      prNumber = match ? match[1] : prArg;
+    } else {
+      const branch = execSync2("git branch --show-current", { encoding: "utf-8" }).trim();
+      const result2 = execSync2(`gh pr list --head "${branch}" --json number --limit 1`, { encoding: "utf-8" });
+      const prs = JSON.parse(result2);
+      if (prs.length === 0)
+        return null;
+      prNumber = prs[0].number.toString();
+    }
+    const result = execSync2(`gh pr view ${prNumber} --json number,title,author,createdAt,mergedAt,additions,deletions`, { encoding: "utf-8" });
+    const pr = JSON.parse(result);
+    return {
+      number: pr.number,
+      title: pr.title,
+      author: pr.author.login,
+      createdAt: pr.createdAt,
+      mergedAt: pr.mergedAt,
+      additions: pr.additions,
+      deletions: pr.deletions
+    };
+  } catch {
+    return null;
+  }
+}
+async function getPRCommits(prNumber) {
+  try {
+    const result = execSync2(`gh pr view ${prNumber} --json commits --jq '.commits[].oid'`, { encoding: "utf-8" });
+    return result.trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function formatNumber(num) {
+  if (num >= 1e6)
+    return `${(num / 1e6).toFixed(1)}M`;
+  if (num >= 1000)
+    return `${Math.round(num / 1000)}K`;
+  return num.toString();
+}
+
+// src/lib/badges.ts
+function computeBadges(score, agents, git) {
+  const badges = [];
+  badges.push({
+    id: "score-50",
+    name: "Getting Started",
+    description: "Reach a score of 50",
+    icon: "\uD83C\uDFAF",
+    tier: "bronze",
+    category: "score",
+    earned: score.overall >= 50,
+    progress: Math.min(100, score.overall / 50 * 100)
+  });
+  badges.push({
+    id: "score-70",
+    name: "Proficient",
+    description: "Reach a score of 70",
+    icon: "⭐",
+    tier: "silver",
+    category: "score",
+    earned: score.overall >= 70,
+    progress: Math.min(100, score.overall / 70 * 100)
+  });
+  badges.push({
+    id: "score-85",
+    name: "Expert",
+    description: "Reach a score of 85",
+    icon: "\uD83C\uDFC6",
+    tier: "gold",
+    category: "score",
+    earned: score.overall >= 85,
+    progress: Math.min(100, score.overall / 85 * 100)
+  });
+  badges.push({
+    id: "score-95",
+    name: "Elite",
+    description: "Reach a score of 95+",
+    icon: "\uD83D\uDC8E",
+    tier: "diamond",
+    category: "score",
+    earned: score.overall >= 95,
+    progress: Math.min(100, score.overall / 95 * 100)
+  });
+  const wastePercent = score.tokenEfficiency.wastePercentage;
+  badges.push({
+    id: "low-waste",
+    name: "Token Saver",
+    description: "Keep token waste below 10%",
+    icon: "\uD83D\uDCB0",
+    tier: "silver",
+    category: "efficiency",
+    earned: wastePercent < 10,
+    progress: wastePercent < 10 ? 100 : Math.max(0, 100 - (wastePercent - 10) * 5)
+  });
+  badges.push({
+    id: "ultra-efficient",
+    name: "Ultra Efficient",
+    description: "Keep token waste below 5%",
+    icon: "\uD83D\uDD25",
+    tier: "gold",
+    category: "efficiency",
+    earned: wastePercent < 5,
+    progress: wastePercent < 5 ? 100 : Math.max(0, 100 - wastePercent * 10)
+  });
+  if (agents) {
+    const sessionCount = agents.totalSessions;
+    badges.push({
+      id: "first-session",
+      name: "First Steps",
+      description: "Complete your first AI session",
+      icon: "\uD83D\uDC63",
+      tier: "bronze",
+      category: "consistency",
+      earned: sessionCount >= 1,
+      progress: sessionCount >= 1 ? 100 : 0
+    });
+    badges.push({
+      id: "power-user",
+      name: "Power User",
+      description: "Complete 100 AI sessions",
+      icon: "⚡",
+      tier: "silver",
+      category: "consistency",
+      earned: sessionCount >= 100,
+      progress: Math.min(100, sessionCount / 100 * 100)
+    });
+    badges.push({
+      id: "ai-native",
+      name: "AI Native",
+      description: "Complete 500 AI sessions",
+      icon: "\uD83E\uDD16",
+      tier: "gold",
+      category: "consistency",
+      earned: sessionCount >= 500,
+      progress: Math.min(100, sessionCount / 500 * 100)
+    });
+    const frustrationCount = agents.sessions.reduce((acc, s2) => acc + s2.patterns.filter((p) => p.type !== "smooth_flow").reduce((a2, p) => a2 + p.count, 0), 0);
+    const smoothRatio = sessionCount > 0 ? 1 - frustrationCount / sessionCount / 5 : 0;
+    badges.push({
+      id: "smooth-operator",
+      name: "Smooth Operator",
+      description: "Maintain low frustration across sessions",
+      icon: "\uD83D\uDE0E",
+      tier: "gold",
+      category: "efficiency",
+      earned: smoothRatio > 0.8 && sessionCount >= 10,
+      progress: Math.min(100, smoothRatio * 100)
+    });
+    const modelCount = Object.keys(agents.modelBreakdown).length;
+    badges.push({
+      id: "model-explorer",
+      name: "Model Explorer",
+      description: "Use 3+ different AI models",
+      icon: "\uD83D\uDD2C",
+      tier: "bronze",
+      category: "tools",
+      earned: modelCount >= 3,
+      progress: Math.min(100, modelCount / 3 * 100)
+    });
+  }
+  if (git) {
+    badges.push({
+      id: "commit-streak",
+      name: "Commit Machine",
+      description: "Average 5+ commits per day",
+      icon: "\uD83D\uDCDD",
+      tier: "silver",
+      category: "consistency",
+      earned: git.commitsPerDay >= 5,
+      progress: Math.min(100, git.commitsPerDay / 5 * 100)
+    });
+    badges.push({
+      id: "small-commits",
+      name: "Atomic Commits",
+      description: "Keep average commit size under 50 lines",
+      icon: "\uD83C\uDFAF",
+      tier: "silver",
+      category: "efficiency",
+      earned: git.avgCommitSize < 50,
+      progress: git.avgCommitSize < 50 ? 100 : Math.max(0, 100 - (git.avgCommitSize - 50))
+    });
+  }
+  const allPhasesAbove60 = score.phases.every((p) => p.score >= 60);
+  badges.push({
+    id: "full-coverage",
+    name: "Full Coverage",
+    description: "Score 60+ in all SDLC phases",
+    icon: "\uD83C\uDF1F",
+    tier: "gold",
+    category: "score",
+    earned: allPhasesAbove60,
+    progress: Math.min(100, score.phases.filter((p) => p.score >= 60).length / score.phases.length * 100)
+  });
+  const implementationPhase = score.phases.find((p) => p.phase === "implementation");
+  if (implementationPhase && implementationPhase.score >= 80) {
+    badges.push({
+      id: "code-wizard",
+      name: "Code Wizard",
+      description: "Score 80+ in implementation phase",
+      icon: "\uD83E\uDDD9",
+      tier: "platinum",
+      category: "score",
+      earned: true
+    });
+  }
+  const testingPhase = score.phases.find((p) => p.phase === "testing");
+  if (testingPhase && testingPhase.score >= 80) {
+    badges.push({
+      id: "test-champion",
+      name: "Test Champion",
+      description: "Score 80+ in testing phase",
+      icon: "✅",
+      tier: "platinum",
+      category: "score",
+      earned: true
+    });
+  }
+  return badges;
+}
+function formatBadge(badge) {
+  const tierColors = {
+    bronze: "\x1B[33m",
+    silver: "\x1B[37m",
+    gold: "\x1B[93m",
+    platinum: "\x1B[96m",
+    diamond: "\x1B[95m"
+  };
+  const reset2 = "\x1B[0m";
+  const dim2 = "\x1B[2m";
+  const color = tierColors[badge.tier] || "";
+  const checkmark = badge.earned ? "✓" : "○";
+  const progressStr = badge.earned ? "" : ` ${dim2}(${Math.round(badge.progress || 0)}%)${reset2}`;
+  return `${checkmark} ${badge.icon} ${color}${badge.name}${reset2}${progressStr}`;
+}
+function getEarnedBadges(badges) {
+  return badges.filter((b2) => b2.earned);
+}
+function getBadgesByCategory(badges, category) {
+  return badges.filter((b2) => b2.category === category);
+}
+
+// src/commands/badges.ts
+var badgesCommand = defineCommand2({
+  meta: {
+    name: "badges",
+    description: "View your earned badges and achievements"
+  },
+  args: {
+    all: {
+      type: "boolean",
+      description: "Show all badges including unearned",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const jsonOutput = args.json;
+    const showAll = args.all;
+    if (!jsonOutput) {
+      console.log();
+      console.log(colors2.bold(colors2.primary("  Badges & Achievements")));
+      console.log(colors2.dim("  " + "─".repeat(40)));
+      console.log();
+    }
+    const spinner = jsonOutput ? null : createSpinner("Computing badges...");
+    if (spinner)
+      spinner.start();
+    const since = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+    const projectDir = process.cwd();
+    const git = await collectGit(projectDir, since);
+    const agents = await collectAgentSessions(since);
+    const tests = await collectTestResults(projectDir);
+    const score = computeNaironScore(git ?? undefined, agents ?? undefined, tests ?? undefined);
+    const allBadges = computeBadges(score, agents, git);
+    const earnedBadges = getEarnedBadges(allBadges);
+    if (spinner)
+      spinner.succeed(`${earnedBadges.length}/${allBadges.length} badges earned`);
+    if (jsonOutput) {
+      console.log(JSON.stringify({
+        earned: earnedBadges.length,
+        total: allBadges.length,
+        badges: showAll ? allBadges : earnedBadges
+      }, null, 2));
+      return;
+    }
+    console.log();
+    const categories = ["score", "efficiency", "consistency", "tools", "special"];
+    const categoryNames = {
+      score: "Score Milestones",
+      efficiency: "Efficiency",
+      consistency: "Consistency",
+      tools: "Tools & Models",
+      special: "Special"
+    };
+    for (const category of categories) {
+      const categoryBadges = getBadgesByCategory(allBadges, category);
+      const badgesToShow = showAll ? categoryBadges : categoryBadges.filter((b2) => b2.earned);
+      if (badgesToShow.length === 0)
+        continue;
+      console.log(`  ${colors2.bold(categoryNames[category])}`);
+      console.log();
+      for (const badge of badgesToShow) {
+        console.log(`    ${formatBadge(badge)}`);
+        if (showAll && !badge.earned) {
+          console.log(`      ${colors2.dim(badge.description)}`);
+        }
+      }
+      console.log();
+    }
+    const earnedCount = earnedBadges.length;
+    const totalCount = allBadges.length;
+    const percentage = Math.round(earnedCount / totalCount * 100);
+    console.log(colors2.dim("  " + "─".repeat(40)));
+    console.log(`  ${icons.success} ${colors2.bold(`${earnedCount}/${totalCount}`)} badges earned ${colors2.dim(`(${percentage}%)`)}`);
+    if (!showAll && earnedCount < totalCount) {
+      console.log(`  ${colors2.dim(`Run ${colors2.primary("nb badges --all")} to see all available badges`)}`);
+    }
+    console.log();
+  }
+});
+
 // src/index.ts
 var VERSION = "0.0.13";
 var CYAN = "\x1B[36m";
@@ -16984,7 +17454,7 @@ function showBanner() {
   log("");
 }
 var args = process.argv.slice(2);
-var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export"];
+var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export", "pr", "badges"];
 var hasSubcommand = args.some((arg) => subcommands.includes(arg));
 var hasHelp = args.includes("--help") || args.includes("-h");
 var hasVersion = args.includes("--version");
@@ -17009,7 +17479,9 @@ if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
       history: historyCommand,
       cost: costCommand,
       session: sessionCommand,
-      export: exportCommand
+      export: exportCommand,
+      pr: prCommand,
+      badges: badgesCommand
     }
   });
   runMain(main);

package/package.json

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