chekk 0.2.0 → 0.2.2

package/bin/chekk.js

@@ -8,7 +8,7 @@ const program = new Command();
 program
   .name('chekk')
   .description('The engineering capability score. See how you prompt.')
-  .version('0.2.0')
+  .version('0.2.2')
   .option('--offline', 'Skip AI prose generation, show data-driven output')
   .option('--verbose', 'Show detailed per-project and per-metric breakdowns')
   .option('--json', 'Output raw metrics as JSON')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chekk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "See how you prompt. Chekk analyzes your AI coding workflow and tells you what kind of engineer you are.",
   "bin": {
     "chekk": "./bin/chekk.js"

package/src/display.js

@@ -12,7 +12,8 @@ const white = chalk.white;
 
 function tierColor(tier) {
   if (tier === 'LEGENDARY') return gold;
-  if (tier === 'RARE') return purple;
+  if (tier === 'ULTRA RARE') return purple;
+  if (tier === 'RARE') return cyan;
   if (tier === 'UNCOMMON') return blue;
   return dim;
 }
@@ -67,11 +68,11 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.0')}`,
+    `   ${bold.white('chekk')}${dim(' v0.2.2')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
-  for (const l of box(lines)) console.log(l);
+  for (const l of box(lines, 45)) console.log(l);
   console.log();
 }
 
@@ -130,7 +131,7 @@ export async function displayProgressBar(durationMs = 2000) {
 // ══════════════════════════════════════════════
 
 export function displayScore(result, prose) {
-  const { overall, scores, archetype, tier } = result;
+  const { overall, scores, archetype, tier, tierBadge, tierPercentile } = result;
   const tc = tierColor(tier);
   const sc = scoreColor(overall);
 
@@ -140,7 +141,9 @@ export function displayScore(result, prose) {
   console.log(dim('  YOUR CHEKK SCORE'));
   console.log();
   console.log(`                    ${sc.bold(String(overall))}`);
-  console.log(`               ${tc('\u2500\u2500 ' + tier + ' \u2500\u2500')}`);
+  const badgeStr = tierBadge ? ` ${tierBadge}` : '';
+  const pctStr = tierPercentile ? `  ${dim(tierPercentile)}` : '';
+  console.log(`               ${tc('\u2500\u2500 ' + tier + ' \u2500\u2500')}${badgeStr}${pctStr}`);
   console.log();
   console.log(`  ${dim('Archetype:')} ${bold.white(archetype.name)}`);
 
@@ -153,15 +156,28 @@ export function displayScore(result, prose) {
 
   // Dimensions box
   console.log(dim('  DIMENSIONS\n'));
+
+  // Build dimension lines with fixed-width layout
+  // Format: "  Label          ██████████████░░░░  XX "
+  // Visible: 2 + 15 + 18 + 2 + 3 + 1 = ~41 chars
+  function dimLine(label, score) {
+    const labelStr = bold(label);
+    const labelVisible = label.length;
+    const labelPad = ' '.repeat(Math.max(0, 15 - labelVisible));
+    const scoreStr = String(score);
+    const scorePad = score < 10 ? '  ' : score < 100 ? ' ' : '';
+    return `  ${labelStr}${labelPad}${progressBar(score)} ${scorePad}${bold(scoreStr)} `;
+  }
+
   const dimLines = [
     '',
-    `  ${pad(bold('Thinking'), 20)}  ${progressBar(scores.decomposition)}  ${bold(String(scores.decomposition))}`,
-    `  ${pad(bold('Debugging'), 20)} ${progressBar(scores.debugCycles)}  ${bold(String(scores.debugCycles))}`,
-    `  ${pad(bold('AI Leverage'), 20)}${progressBar(scores.aiLeverage)}  ${bold(String(scores.aiLeverage))}`,
-    `  ${pad(bold('Workflow'), 20)}  ${progressBar(scores.sessionStructure)}  ${bold(String(scores.sessionStructure))}`,
+    dimLine('Thinking', scores.decomposition),
+    dimLine('Debugging', scores.debugCycles),
+    dimLine('AI Leverage', scores.aiLeverage),
+    dimLine('Workflow', scores.sessionStructure),
     '',
   ];
-  for (const l of box(dimLines)) console.log(l);
+  for (const l of box(dimLines, 45)) console.log(l);
   console.log();
 }
 
@@ -259,7 +275,7 @@ export function displayEasterEggs(result, metrics) {
 // ══════════════════════════════════════════════
 
 export function displayEnding(result) {
-  const { overall, archetype, tier } = result;
+  const { overall, archetype, tier, tierBadge } = result;
   const tc = tierColor(tier);
 
   console.log(doubleRule());
@@ -269,7 +285,8 @@ export function displayEnding(result) {
   console.log();
 
   // Copy-paste share line
-  const shareLine = `${overall} \u2014 ${tier} \u2014 ${archetype.name}`;
+  const badge = tierBadge ? ` ${tierBadge}` : '';
+  const shareLine = `${overall} \u2014 ${tier}${badge} \u2014 ${archetype.name}`;
   console.log(`  ${dim('"')}${tc(shareLine)}${dim('"')}`);
   console.log(`  ${dim('\u2191 Copy this to share')}`);
   console.log();

package/src/index.js

@@ -15,7 +15,7 @@ import {
   displayOffline,
   displayVerbose,
 } from './display.js';
-import { generateProse, askClaim, uploadAndClaim } from './upload.js';
+import { generateProse, askVerbose, askClaim, uploadAndClaim } from './upload.js';
 
 export async function run(options = {}) {
   // ── Header ──
@@ -93,35 +93,52 @@ export async function run(options = {}) {
     tools: supported.map(t => t.tool),
   };
 
-  // Progress bar animation
-  await displayProgressBar(1500);
-
   // ── JSON output ──
   if (options.json) {
     console.log(JSON.stringify({ metrics, result, sessionStats }, null, 2));
     return;
   }
 
-  // ── Step 4: Display results ──
+  // ── Step 4: Progress bar + API call in parallel ──
+  // Run prose generation alongside the progress bar so score appears
+  // immediately when the bar hits 100% — no lag.
+  let prose = null;
+  if (!options.offline) {
+    const [, proseResult] = await Promise.all([
+      displayProgressBar(1500),
+      generateProse(metrics, result, sessionStats).catch(() => null),
+    ]);
+    prose = proseResult;
+  } else {
+    await displayProgressBar(1500);
+  }
+
+  // ── Step 5: Display results ──
   if (options.offline) {
     displayOffline(result, metrics);
   } else {
-    // Generate prose from API
-    let prose = null;
-    try {
-      prose = await generateProse(metrics, result, sessionStats);
-    } catch {
-      // Silently fall back to data-driven display
-    }
     displayFull(result, metrics, prose);
   }
 
-  // ── Verbose breakdown ──
+  // ── Step 6: Verbose prompt (interactive) ──
+  // If --verbose flag was passed, show immediately. Otherwise prompt.
   if (options.verbose) {
     displayVerbose(metrics, allSessions);
+  } else {
+    try {
+      const wantsVerbose = await askVerbose();
+      if (wantsVerbose) {
+        console.log();
+        displayVerbose(metrics, allSessions);
+      } else {
+        console.log();
+      }
+    } catch {
+      console.log();
+    }
   }
 
-  // ── Step 5: Claim prompt ──
+  // ── Step 7: Claim prompt ──
   if (options.upload !== false) {
     try {
       const wantsClaim = await askClaim();

package/src/scorer.js

@@ -1,79 +1,162 @@
 /**
  * Combine individual metric scores into composite scores and assign archetype.
+ *
+ * Archetypes and tiers are consistent with the GitHub analysis system.
+ * 15 archetypes across 5 tiers, mapped from repo-based signals to
+ * prompt-behavior signals measured by the CLI.
  */
 
+// ── Tier thresholds (match GitHub analysis) ──
+
+const TIERS = [
+  { name: 'LEGENDARY',  min: 85, badge: '🌟🌟🌟', percentile: 'Top 1%' },
+  { name: 'ULTRA RARE', min: 73, badge: '🌟🌟',   percentile: 'Top 5%' },
+  { name: 'RARE',       min: 60, badge: '⭐',      percentile: 'Top 15%' },
+  { name: 'UNCOMMON',   min: 47, badge: '◆',       percentile: 'Top 30%' },
+  { name: 'COMMON',     min: 0,  badge: '●',       percentile: 'Top 50%' },
+];
+
+// ── Archetype definitions ──
+// Each archetype has a match function based on the 4 CLI dimension scores:
+//   decomposition (thinking), debugCycles (debugging),
+//   aiLeverage (AI leverage), sessionStructure (workflow)
+//
+// Tier-restricted: archetypes only match within their allowed tier range.
+
 const ARCHETYPES = [
+  // ── LEGENDARY (85+) ──
   {
-    id: 'THE_ARCHITECT',
-    name: 'THE ARCHITECT',
-    // High decomposition + high planning + high leverage
-    match: (s) => s.decomposition >= 70 && s.sessionStructure >= 65 && s.aiLeverage >= 65,
+    id: 'THE_10X_ENGINEER',
+    name: 'THE 10X ENGINEER',
+    tierRange: ['LEGENDARY'],
+    match: (s) => true, // If you hit LEGENDARY, you're a 10x
     priority: 1,
   },
+
+  // ── ULTRA RARE (73-84) ──
   {
-    id: 'THE_SURGEON',
-    name: 'THE SURGEON',
-    // High debug efficiency + high leverage + good structure
-    match: (s) => s.debugCycles >= 75 && s.aiLeverage >= 60,
+    id: 'THE_ARCHITECT',
+    name: 'THE ARCHITECT',
+    tierRange: ['ULTRA RARE'],
+    // High decomposition + structured workflow + strong leverage
+    match: (s) => s.decomposition >= 70 && s.sessionStructure >= 65,
     priority: 2,
   },
+  {
+    id: 'THE_PROFESSOR',
+    name: 'THE PROFESSOR',
+    tierRange: ['ULTRA RARE'],
+    // Exceptional at explaining: high decomposition, detailed prompts, strong context-setting
+    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 70,
+    priority: 3,
+  },
+
+  // ── RARE (60-72) ──
+  {
+    id: 'THE_SPECIALIST',
+    name: 'THE SPECIALIST',
+    tierRange: ['RARE'],
+    // Deep focused work: high debug efficiency + high leverage in specific domain
+    match: (s) => s.debugCycles >= 70 && s.aiLeverage >= 65,
+    priority: 4,
+  },
+  {
+    id: 'THE_SYSTEMS_THINKER',
+    name: 'THE SYSTEMS THINKER',
+    tierRange: ['RARE'],
+    // Strong decomposition + structured approach to complex problems
+    match: (s) => s.decomposition >= 65 && s.sessionStructure >= 60,
+    priority: 5,
+  },
+  {
+    id: 'THE_MAINTAINER',
+    name: 'THE MAINTAINER',
+    tierRange: ['RARE'],
+    // Reliable workflow + solid debugging: keeps things running
+    match: (s) => s.sessionStructure >= 60 && s.debugCycles >= 60,
+    priority: 6,
+  },
+
+  // ── UNCOMMON (47-59) ──
+  {
+    id: 'THE_CRAFTSPERSON',
+    name: 'THE CRAFTSPERSON',
+    tierRange: ['UNCOMMON'],
+    // Quality obsession: high debug precision + structured sessions
+    match: (s) => s.debugCycles >= 60 && s.sessionStructure >= 55,
+    priority: 7,
+  },
   {
     id: 'THE_BUILDER',
     name: 'THE BUILDER',
-    // High overall scores, well-rounded
+    tierRange: ['UNCOMMON'],
+    // Well-rounded: decent across all dimensions
     match: (s) => {
-      const avg = (s.decomposition + s.debugCycles + s.aiLeverage + s.sessionStructure) / 4;
-      return avg >= 65 && Math.min(s.decomposition, s.debugCycles, s.aiLeverage, s.sessionStructure) >= 55;
+      const min = Math.min(s.decomposition, s.debugCycles, s.aiLeverage, s.sessionStructure);
+      return min >= 45;
     },
-    priority: 3,
+    priority: 8,
+  },
+  {
+    id: 'THE_CONTRIBUTOR',
+    name: 'THE CONTRIBUTOR',
+    tierRange: ['UNCOMMON'],
+    // Strong AI leverage + decent decomposition: collaborates well with AI
+    match: (s) => s.aiLeverage >= 55 && s.decomposition >= 50,
+    priority: 9,
+  },
+  {
+    id: 'THE_HIDDEN_GEM',
+    name: 'THE HIDDEN GEM',
+    tierRange: ['UNCOMMON'],
+    // Strong skills but unstructured: high debug or leverage but low structure
+    match: (s) => (s.debugCycles >= 55 || s.aiLeverage >= 55) && s.sessionStructure < 50,
+    priority: 10,
   },
   {
     id: 'THE_EXPLORER',
     name: 'THE EXPLORER',
-    // High leverage + high decomposition, loves research
-    match: (s) => s.aiLeverage >= 70 && s.decomposition >= 60,
-    priority: 4,
+    tierRange: ['UNCOMMON'],
+    // High leverage + curiosity-driven: research-heavy prompting
+    match: (s) => s.aiLeverage >= 50,
+    priority: 11,
   },
+
+  // ── COMMON (0-46) ──
   {
-    id: 'THE_SPEEDRUNNER',
-    name: 'THE SPEEDRUNNER',
-    // Quick debug cycles, less structured but efficient
-    match: (s) => s.debugCycles >= 70 && s.sessionStructure < 60,
-    priority: 5,
+    id: 'THE_TINKERER',
+    name: 'THE TINKERER',
+    tierRange: ['COMMON'],
+    // Practical problem-solving: decent debug + some leverage
+    match: (s) => s.debugCycles >= 40 && s.aiLeverage >= 35,
+    priority: 12,
   },
   {
-    id: 'THE_APPRENTICE',
-    name: 'THE APPRENTICE',
-    // Learning patterns - lower scores but shows growth potential
-    match: (s) => {
-      const avg = (s.decomposition + s.debugCycles + s.aiLeverage + s.sessionStructure) / 4;
-      return avg >= 40 && avg < 65;
-    },
-    priority: 6,
+    id: 'THE_GRINDER',
+    name: 'THE GRINDER',
+    tierRange: ['COMMON'],
+    // High volume, iterative: lots of exchanges, keeps going
+    match: (s) => s.decomposition >= 35,
+    priority: 13,
   },
   {
-    id: 'THE_MAVERICK',
-    name: 'THE MAVERICK',
-    // Unstructured but somehow gets things done - low structure, decent other scores
-    match: (s) => s.sessionStructure < 50 && (s.decomposition >= 55 || s.aiLeverage >= 55),
-    priority: 7,
+    id: 'THE_HOBBYIST',
+    name: 'THE HOBBYIST',
+    tierRange: ['COMMON'],
+    // Active but early: some leverage or debugging skill
+    match: (s) => s.aiLeverage >= 30 || s.debugCycles >= 30,
+    priority: 14,
   },
   {
-    id: 'THE_NEWCOMER',
-    name: 'THE NEWCOMER',
-    // Default fallback
+    id: 'THE_APPRENTICE',
+    name: 'THE APPRENTICE',
+    tierRange: ['COMMON'],
+    // Default fallback for COMMON tier
     match: () => true,
     priority: 99,
   },
 ];
 
-const TIERS = [
-  { name: 'LEGENDARY', min: 90 },
-  { name: 'RARE', min: 75 },
-  { name: 'UNCOMMON', min: 55 },
-  { name: 'COMMON', min: 0 },
-];
-
 export function computeOverallScore(metrics) {
   const scores = {
     decomposition: metrics.decomposition.score,
@@ -90,13 +173,18 @@ export function computeOverallScore(metrics) {
     scores.sessionStructure * 0.2
   );
 
-  // Assign archetype
-  const sortedArchetypes = [...ARCHETYPES].sort((a, b) => a.priority - b.priority);
-  const archetype = sortedArchetypes.find(a => a.match(scores)) || ARCHETYPES[ARCHETYPES.length - 1];
-
-  // Assign tier
+  // Assign tier first
   const tier = TIERS.find(t => overall >= t.min) || TIERS[TIERS.length - 1];
 
+  // Assign archetype within tier
+  const tierArchetypes = ARCHETYPES
+    .filter(a => a.tierRange.includes(tier.name))
+    .sort((a, b) => a.priority - b.priority);
+
+  const archetype = tierArchetypes.find(a => a.match(scores))
+    || tierArchetypes[tierArchetypes.length - 1]
+    || { id: 'THE_APPRENTICE', name: 'THE APPRENTICE' };
+
   return {
     overall,
     scores,
@@ -105,5 +193,7 @@ export function computeOverallScore(metrics) {
       name: archetype.name,
     },
     tier: tier.name,
+    tierBadge: tier.badge,
+    tierPercentile: tier.percentile,
   };
 }

package/src/upload.js

@@ -47,6 +47,23 @@ export async function generateProse(metrics, result, sessionStats) {
   return response.json();
 }
 
+/**
+ * Ask user if they want to see detailed breakdown.
+ */
+export function askVerbose() {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question('   See detailed breakdown? (y/n) ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
 /**
  * Ask user if they want to claim their profile.
  */