chekk 0.2.2 → 0.2.3

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.2')
+  .version('0.2.3')
   .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.2",
+  "version": "0.2.3",
   "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

@@ -42,6 +42,28 @@ function pad(str, len) {
   return str + ' '.repeat(Math.max(0, len - visible.length));
 }
 
+function snippet(prompt, maxLen = 70) {
+  if (!prompt) return null;
+  // Clean up whitespace / newlines
+  let clean = prompt.replace(/\s+/g, ' ').trim();
+  if (clean.length > maxLen) {
+    clean = clean.slice(0, maxLen - 1) + '\u2026';
+  }
+  return clean;
+}
+
+function displaySnippet(prompt, maxLen = 70) {
+  const s = snippet(prompt, maxLen);
+  if (!s) return;
+  console.log(`  ${dim('\u201C')}${dim.italic(s)}${dim('\u201D')}`);
+}
+
+function pickExample(examples, type) {
+  if (!examples || !examples.length) return null;
+  const match = examples.find(e => e.type === type);
+  return match ? match.prompt : null;
+}
+
 // ── Box drawing ──
 
 function box(lines, width = 43) {
@@ -68,7 +90,7 @@ export function displayHeader() {
   console.log();
   const lines = [
     '',
-    `   ${bold.white('chekk')}${dim(' v0.2.2')}`,
+    `   ${bold.white('chekk')}${dim(' v0.2.3')}`,
     `   ${dim('the engineering capability score')}`,
     '',
   ];
@@ -196,8 +218,10 @@ export function displayNarratives(metrics, prose) {
       }
       console.log();
     }
+    // Show prompt evidence after AI prose
+    displayPromptEvidence(metrics);
   } else {
-    // Fallback: data-driven bullet points
+    // Fallback: data-driven bullet points with inline snippets
     displayDataNarratives(metrics);
   }
 }
@@ -207,6 +231,20 @@ function displayDataNarratives(metrics) {
   const db = metrics.debugCycles.details;
   const ai = metrics.aiLeverage.details;
   const ss = metrics.sessionStructure.details;
+  const dEx = metrics.decomposition.examples || [];
+  const dbEx = metrics.debugCycles.examples || [];
+  const aiEx = metrics.aiLeverage.examples || [];
+  const ssEx = metrics.sessionStructure.examples || [];
+
+  // Track shown snippets to avoid duplicates
+  const shownSnippets = new Set();
+  function showUniqueSnippet(prompt) {
+    if (!prompt) return;
+    const s = snippet(prompt, 70);
+    if (shownSnippets.has(s)) return;
+    shownSnippets.add(s);
+    displaySnippet(prompt);
+  }
 
   // Thinking
   console.log(`  ${bold('\uD83E\uDDE0 THINKING')}`);
@@ -214,6 +252,7 @@ function displayDataNarratives(metrics) {
   console.log(`  ${dim(exchPerSession > 20 ? `${exchPerSession} avg exchanges/session \u2014 marathon builder` : exchPerSession > 8 ? `${exchPerSession} avg exchanges/session \u2014 iterative` : `${exchPerSession} avg exchanges/session \u2014 concise`)}`);
   console.log(`  ${dim(d.avgPromptLength > 500 ? `${numberFormat(d.avgPromptLength)} char avg prompt \u2014 thinks out loud` : `${d.avgPromptLength} char avg prompt \u2014 concise communicator`)}`);
   console.log(`  ${dim(d.multiStepSessions > d.singleShotSessions * 2 ? 'Multi-step decomposition over single-shot' : 'Mix of multi-step and single-shot sessions')}`);
+  showUniqueSnippet(pickExample(dEx, 'decomposition'));
   console.log();
 
   // Debugging
@@ -222,6 +261,7 @@ function displayDataNarratives(metrics) {
   console.log(`  ${dim(turns <= 2 ? `${turns} turns to resolve \u2014 surgical` : turns <= 4 ? `${turns} turns to resolve \u2014 efficient` : `${turns} turns to resolve \u2014 iterative`)}`);
   console.log(`  ${dim(`${db.specificReportRatio}% specific error reports`)}`);
   console.log(`  ${dim(db.longLoops === 0 ? 'Zero extended debug loops detected' : `${db.longLoops} extended debug loops`)}`);
+  showUniqueSnippet(pickExample(dbEx, 'specific_report') || pickExample(dbEx, 'quick_fix'));
   console.log();
 
   // AI Leverage
@@ -230,6 +270,7 @@ function displayDataNarratives(metrics) {
   const codingRatio = ai.toolDiversity.coding > ai.toolDiversity.research ? 'Coding-heavy' : 'Research-heavy';
   console.log(`  ${dim(`${codingRatio} over ${ai.toolDiversity.coding > ai.toolDiversity.research ? 'research' : 'coding'}-heavy`)}`);
   console.log(`  ${dim(`${ai.architecturalPrompts} architectural, ${ai.planningPrompts} planning, ${ai.exploratoryPrompts} exploratory`)}`);
+  showUniqueSnippet(pickExample(aiEx, 'architectural') || pickExample(aiEx, 'planning'));
   console.log();
 
   // Workflow
@@ -237,6 +278,51 @@ function displayDataNarratives(metrics) {
   console.log(`  ${dim(`${ss.contextSetRatio}% context-setting rate \u2014 ${ss.contextSetRatio > 50 ? 'deliberate' : ss.contextSetRatio > 25 ? 'moderate' : 'low'}`)}`);
   console.log(`  ${dim(`${ss.reviewEndRatio}% sessions end with review`)}`);
   console.log(`  ${dim(`${ss.refinementRatio}% refinement rate \u2014 ${ss.refinementRatio > 20 ? 'critical eye' : 'accepts readily'}`)}`);
+  showUniqueSnippet(pickExample(ssEx, 'context_setting') || pickExample(ssEx, 'refinement'));
+  console.log();
+}
+
+// ── Prompt evidence block (shown after AI prose) ──
+
+function displayPromptEvidence(metrics) {
+  const allExamples = [
+    ...(metrics.decomposition.examples || []),
+    ...(metrics.debugCycles.examples || []),
+    ...(metrics.aiLeverage.examples || []),
+    ...(metrics.sessionStructure.examples || []),
+  ];
+
+  if (allExamples.length === 0) return;
+
+  // Pick up to 3 best examples to show as evidence, deduplicated
+  const candidates = [];
+  const arch = pickExample(metrics.aiLeverage.examples, 'architectural');
+  const decomp = pickExample(metrics.decomposition.examples, 'decomposition');
+  const debug = pickExample(metrics.debugCycles.examples, 'specific_report');
+  const ctx = pickExample(metrics.sessionStructure.examples, 'context_setting');
+
+  if (arch) candidates.push({ label: 'Architecture', prompt: arch });
+  if (decomp) candidates.push({ label: 'Thinking', prompt: decomp });
+  if (debug) candidates.push({ label: 'Debugging', prompt: debug });
+  if (ctx) candidates.push({ label: 'Context', prompt: ctx });
+
+  // Deduplicate by snippet text
+  const picks = [];
+  const seen = new Set();
+  for (const c of candidates) {
+    const s = snippet(c.prompt, 65);
+    if (!seen.has(s)) {
+      seen.add(s);
+      picks.push(c);
+    }
+  }
+
+  if (picks.length === 0) return;
+
+  console.log(dim('  YOUR PROMPTS\n'));
+  for (const pick of picks.slice(0, 3)) {
+    console.log(`  ${dim(pick.label + ':')} ${dim('\u201C')}${dim.italic(snippet(pick.prompt, 65))}${dim('\u201D')}`);
+  }
   console.log();
 }
 

package/src/metrics/ai-leverage.js

@@ -37,15 +37,32 @@ export function computeAILeverage(sessions) {
   let complexPrompts = 0; // > 200 chars with multiple sentences
   let trivialPrompts = 0; // < 50 chars, simple commands
 
+  // Capture representative examples
+  let bestArchPrompt = null; // best architectural prompt
+  let bestPlanPrompt = null; // best planning prompt
+  let bestExplorePrompt = null; // best exploratory prompt
+  let bestArchLen = 0;
+  let bestPlanLen = 0;
+  let bestExploreLen = 0;
+
   for (const session of sessions) {
     for (const exchange of session.exchanges) {
       const prompt = exchange.userPrompt || '';
       totalPrompts++;
 
       // Categorize prompt type
-      if (architecturalPatterns.test(prompt)) architecturalPrompts++;
-      if (planningPatterns.test(prompt)) planningPrompts++;
-      if (exploratoryPatterns.test(prompt)) exploratoryPrompts++;
+      if (architecturalPatterns.test(prompt)) {
+        architecturalPrompts++;
+        if (prompt.length > bestArchLen) { bestArchLen = prompt.length; bestArchPrompt = prompt; }
+      }
+      if (planningPatterns.test(prompt)) {
+        planningPrompts++;
+        if (prompt.length > bestPlanLen) { bestPlanLen = prompt.length; bestPlanPrompt = prompt; }
+      }
+      if (exploratoryPatterns.test(prompt)) {
+        exploratoryPrompts++;
+        if (prompt.length > bestExploreLen) { bestExploreLen = prompt.length; bestExplorePrompt = prompt; }
+      }
       if (boilerplatePatterns.test(prompt)) boilerplatePrompts++;
       if (testingPatterns.test(prompt)) testingPrompts++;
 
@@ -103,6 +120,12 @@ export function computeAILeverage(sessions) {
     50 * 0  // baseline filler
   );
 
+  // Build examples — pick the best one available
+  const examples = [];
+  if (bestArchPrompt) examples.push({ type: 'architectural', prompt: bestArchPrompt });
+  if (bestPlanPrompt) examples.push({ type: 'planning', prompt: bestPlanPrompt });
+  if (bestExplorePrompt) examples.push({ type: 'exploratory', prompt: bestExplorePrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -120,5 +143,6 @@ export function computeAILeverage(sessions) {
         coding: codingToolUses,
       },
     },
+    examples,
   };
 }

package/src/metrics/debug-cycles.js

@@ -26,10 +26,16 @@ export function computeDebugCycles(sessions) {
   let quickFixes = 0; // resolved in 1-2 turns
   let longLoops = 0; // > 5 turns to resolve
 
+  // Capture representative examples
+  let bestSpecificReport = null; // best specific error report
+  let bestQuickFix = null; // prompt that led to quick resolution
+  let bestSpecificLen = 0;
+
   for (const session of sessions) {
     const { exchanges } = session;
     let inDebugMode = false;
     let debugTurnCount = 0;
+    let debugStartPrompt = null;
 
     for (let i = 0; i < exchanges.length; i++) {
       const prompt = exchanges[i].userPrompt || '';
@@ -39,6 +45,7 @@ export function computeDebugCycles(sessions) {
           // Starting a new debug sequence
           inDebugMode = true;
           debugTurnCount = 1;
+          debugStartPrompt = prompt;
           totalDebugSequences++;
         } else {
           debugTurnCount++;
@@ -50,21 +57,31 @@ export function computeDebugCycles(sessions) {
         }
         if (specificDebugPatterns.test(prompt) || prompt.length > 200) {
           specificReports++;
+          // Track best specific report
+          if (prompt.length > bestSpecificLen) {
+            bestSpecificLen = prompt.length;
+            bestSpecificReport = prompt;
+          }
         }
       } else if (inDebugMode) {
         // Check if this exchange resolves the debug
         if (resolutionPatterns.test(prompt)) {
           totalTurnsToResolve += debugTurnCount;
-          if (debugTurnCount <= 2) quickFixes++;
+          if (debugTurnCount <= 2) {
+            quickFixes++;
+            if (!bestQuickFix) bestQuickFix = debugStartPrompt;
+          }
           if (debugTurnCount > 5) longLoops++;
           inDebugMode = false;
           debugTurnCount = 0;
+          debugStartPrompt = null;
         } else {
           // Moved on without explicit resolution
           totalTurnsToResolve += debugTurnCount;
           unresolvedSequences++;
           inDebugMode = false;
           debugTurnCount = 0;
+          debugStartPrompt = null;
         }
       }
     }
@@ -109,6 +126,11 @@ export function computeDebugCycles(sessions) {
     (100 - longLoopPenalty) * 0.15
   );
 
+  // Build examples array
+  const examples = [];
+  if (bestSpecificReport) examples.push({ type: 'specific_report', prompt: bestSpecificReport });
+  if (bestQuickFix) examples.push({ type: 'quick_fix', prompt: bestQuickFix });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -120,5 +142,6 @@ export function computeDebugCycles(sessions) {
       vagueReports,
       specificReports,
     },
+    examples,
   };
 }

package/src/metrics/decomposition.js

@@ -26,6 +26,11 @@ export function computeDecomposition(sessions) {
   const followupPatterns = /^(now |next |then |also |and |ok |okay |great |good |perfect |after that|building on|following up|continuing)/i;
   const refinementPatterns = /^(actually |wait |hmm |instead |change |modify |update |tweak |adjust |fix |but )/i;
 
+  // Capture representative prompt examples
+  // Keep top 3 candidates and pick the 2nd-longest to avoid overlap with other metrics
+  const decompCandidates = [];
+  let bestFollowupPrompt = null;
+
   for (const session of sessions) {
     const { exchanges } = session;
     totalExchanges += exchanges.length;
@@ -45,10 +50,19 @@ export function computeDecomposition(sessions) {
       if (len > 500) longPromptCount++;
       if (len < 100) shortPromptCount++;
 
+      // Track decomposition examples (multi-sentence prompts showing task breakdown)
+      if (len > 150 && len < 2000) {
+        decompCandidates.push(prompt);
+      }
+
       // Check for contextual followups (not the first prompt in a session)
       if (i > 0) {
         if (followupPatterns.test(prompt) || refinementPatterns.test(prompt)) {
           contextualFollowups++;
+          // Capture best followup example
+          if (!bestFollowupPrompt || prompt.length > bestFollowupPrompt.length) {
+            bestFollowupPrompt = prompt;
+          }
         }
       }
     }
@@ -83,6 +97,16 @@ export function computeDecomposition(sessions) {
     depthScore * 0.2
   );
 
+  // Build examples array — pick a mid-length prompt to avoid overlap with other metrics
+  const examples = [];
+  if (decompCandidates.length > 0) {
+    decompCandidates.sort((a, b) => b.length - a.length);
+    // Pick ~median length to avoid the longest (which will also match ai-leverage)
+    const pickIdx = Math.min(Math.floor(decompCandidates.length / 3), decompCandidates.length - 1);
+    examples.push({ type: 'decomposition', prompt: decompCandidates[pickIdx] });
+  }
+  if (bestFollowupPrompt) examples.push({ type: 'followup', prompt: bestFollowupPrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -94,5 +118,6 @@ export function computeDecomposition(sessions) {
       longPromptRatio: promptCount > 0 ? Math.round(longPromptCount / promptCount * 100) : 0,
       contextualFollowupRatio: promptCount > 0 ? Math.round(followupRatio * 100) : 0,
     },
+    examples,
   };
 }

package/src/metrics/session-structure.js

@@ -34,6 +34,11 @@ export function computeSessionStructure(sessions) {
   // First prompt length distribution (longer first prompts = more context setting)
   let firstPromptTotalLength = 0;
 
+  // Capture representative examples
+  let bestContextPrompt = null; // best context-setting opener
+  let bestRefinementPrompt = null; // best refinement/critical feedback
+  let bestContextLen = 0;
+
   for (const session of sessions) {
     const { exchanges, durationMinutes } = session;
     if (exchanges.length === 0) continue;
@@ -46,6 +51,11 @@ export function computeSessionStructure(sessions) {
 
     if (contextSettingPatterns.test(firstPrompt) || firstPrompt.length > 200) {
       contextSetSessions++;
+      // Track best context-setting prompt
+      if (firstPrompt.length > bestContextLen) {
+        bestContextLen = firstPrompt.length;
+        bestContextPrompt = firstPrompt;
+      }
     }
 
     if (planningStartPatterns.test(firstPrompt)) {
@@ -66,6 +76,10 @@ export function computeSessionStructure(sessions) {
       const prompt = exchanges[i].userPrompt || '';
       if (refinementPatterns.test(prompt)) {
         refinementCount++;
+        // Track best refinement example
+        if (!bestRefinementPrompt || prompt.length > bestRefinementPrompt.length) {
+          bestRefinementPrompt = prompt;
+        }
       }
     }
 
@@ -115,6 +129,11 @@ export function computeSessionStructure(sessions) {
     firstPromptScore * 0.15
   );
 
+  // Build examples array
+  const examples = [];
+  if (bestContextPrompt) examples.push({ type: 'context_setting', prompt: bestContextPrompt });
+  if (bestRefinementPrompt) examples.push({ type: 'refinement', prompt: bestRefinementPrompt });
+
   return {
     score: Math.max(0, Math.min(100, score)),
     details: {
@@ -130,5 +149,6 @@ export function computeSessionStructure(sessions) {
         focused: focusedSessions,
       },
     },
+    examples,
   };
 }

package/src/upload.js

@@ -5,24 +5,38 @@ const API_BASE = 'https://chekk-production.up.railway.app/api/v1';
 /**
  * Call the Chekk API to generate personalized prose from metrics.
  */
+function truncateExamples(examples, maxLen = 120) {
+  if (!examples || !examples.length) return [];
+  return examples.map(e => ({
+    type: e.type,
+    prompt: e.prompt && e.prompt.length > maxLen
+      ? e.prompt.replace(/\s+/g, ' ').trim().slice(0, maxLen) + '...'
+      : (e.prompt || '').replace(/\s+/g, ' ').trim(),
+  }));
+}
+
 export async function generateProse(metrics, result, sessionStats) {
   const payload = {
     metrics: {
       decomposition: {
         score: metrics.decomposition.score,
         details: metrics.decomposition.details,
+        examples: truncateExamples(metrics.decomposition.examples),
       },
       debugCycles: {
         score: metrics.debugCycles.score,
         details: metrics.debugCycles.details,
+        examples: truncateExamples(metrics.debugCycles.examples),
       },
       aiLeverage: {
         score: metrics.aiLeverage.score,
         details: metrics.aiLeverage.details,
+        examples: truncateExamples(metrics.aiLeverage.examples),
       },
       sessionStructure: {
         score: metrics.sessionStructure.score,
         details: metrics.sessionStructure.details,
+        examples: truncateExamples(metrics.sessionStructure.examples),
       },
     },
     result: {