howamiprompting 0.0.0-stage → 0.1.0

package/src/collect/vscode.js

@@ -0,0 +1,112 @@
+// VS Code–family editors: Cursor (Chat/Composer/Agent), VS Code Copilot Chat, Windsurf, Antigravity, Trae, Kiro, VSCodium…
+// plus Cline / Roo Code / Kilo Code task histories stored in each editor's globalStorage.
+import fs from 'node:fs';
+import path from 'node:path';
+import { appSupport, find, isDir, readJson, projectName, exists } from '../util.js';
+import { query } from '../sqlite.js';
+
+export const id = 'vscode-family';
+export const name = 'Editors';
+
+const APPS = ['Cursor', 'Code', 'Code - Insiders', 'VSCodium', 'Windsurf', 'Windsurf - Next', 'Antigravity', 'Trae', 'Kiro', 'Void', 'Positron'];
+const AGENT_EXT = { 'saoudrizwan.claude-dev': 'Cline', 'rooveterinaryinc.roo-cline': 'Roo Code', 'kilocode.kilo-code': 'Kilo Code' };
+
+function workspaceProject(wsDir) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(wsDir, 'workspace.json'), 'utf8'));
+    return projectName(decodeURIComponent(String(j.folder || j.workspace || '').replace(/^file:\/\//, '')));
+  } catch { return null; }
+}
+const parse = s => { try { return typeof s === 'string' ? JSON.parse(s) : s; } catch { return null; } };
+
+export async function collect(log = () => {}) {
+  const out = [];
+  for (const app of APPS) {
+    const user = path.join(appSupport(), app, 'User');
+    if (!isDir(user)) continue;
+    const tool = app === 'Code' || app === 'Code - Insiders' ? 'Copilot Chat' : app;
+
+    // 1) Copilot-style chat sessions (JSON files per workspace)
+    const ws = path.join(user, 'workspaceStorage');
+    if (isDir(ws)) {
+      for (const d of fs.readdirSync(ws)) {
+        const wsDir = path.join(ws, d);
+        const project = workspaceProject(wsDir);
+        const cs = path.join(wsDir, 'chatSessions');
+        if (isDir(cs)) {
+          for (const f of fs.readdirSync(cs).filter(f => f.endsWith('.json'))) {
+            const j = await readJson(path.join(cs, f));
+            let last = '';
+            for (const r of j?.requests || []) {
+              const text = r.message?.text || (r.message?.parts || []).map(p => p.text || '').join('');
+              if (text) out.push({ tool, session: j.sessionId || f, project, ts: r.timestamp || j.creationDate, text, context: last.slice(-400) });
+              last = (r.response || []).map(x => typeof x?.value === 'string' ? x.value : (x?.value?.value || '')).join('');
+            }
+          }
+        }
+        // 2) Cursor legacy prompt list in per-workspace state.vscdb
+        const db = path.join(wsDir, 'state.vscdb');
+        if (app === 'Cursor' && exists(db)) {
+          const rows = await query(db, "SELECT value FROM ItemTable WHERE key = 'aiService.prompts'");
+          for (const row of rows || []) for (const p of parse(row.value) || []) {
+            if (p?.text) out.push({ tool, session: 'ws-' + d, project, ts: null, text: p.text, context: '' });
+          }
+        }
+      }
+    }
+
+    // 3) Cursor Composer / Agent bubbles (global state.vscdb, table cursorDiskKV)
+    const gdb = path.join(user, 'globalStorage', 'state.vscdb');
+    if (exists(gdb) && (app === 'Cursor' || app === 'Windsurf' || app === 'Antigravity' || app === 'Trae')) {
+      const comps = await query(gdb, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'");
+      if (comps) {
+        const bubbles = await query(gdb, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'") || [];
+        const byComposer = new Map();
+        for (const b of bubbles) {
+          const [, cid, bid] = b.key.split(':');
+          const v = parse(b.value);
+          if (!v) continue;
+          if (!byComposer.has(cid)) byComposer.set(cid, new Map());
+          byComposer.get(cid).set(bid, v);
+        }
+        for (const c of comps) {
+          const cd = parse(c.value);
+          if (!cd) continue;
+          const cid = c.key.split(':')[1];
+          const ts = cd.createdAt || null;
+          let seq = [];
+          if (Array.isArray(cd.conversation) && cd.conversation.length) seq = cd.conversation; // older inline format
+          else if (Array.isArray(cd.fullConversationHeadersOnly)) seq = cd.fullConversationHeadersOnly.map(h => byComposer.get(cid)?.get(h.bubbleId) || { type: h.type });
+          let last = '';
+          for (const m of seq) {
+            const t = m.text || '';
+            if (m.type === 1 && t) out.push({ tool, session: cid, project: projectName(cd.context?.folderSelections?.[0]?.relativePath) || null, ts: m.createdAt || ts, text: t, context: last.slice(-400) });
+            else if (m.type === 2 && t) last = t;
+          }
+        }
+      }
+    }
+
+    // 4) Cline / Roo / Kilo task histories
+    for (const [ext, agent] of Object.entries(AGENT_EXT)) {
+      const tasks = path.join(user, 'globalStorage', ext, 'tasks');
+      if (!isDir(tasks)) continue;
+      const files = await find(tasks, (p, n) => n === 'api_conversation_history.json', { depth: 2 });
+      for (const f of files) {
+        const j = await readJson(f);
+        const taskId = path.basename(path.dirname(f));
+        let last = '';
+        for (const m of Array.isArray(j) ? j : []) {
+          const parts = typeof m.content === 'string' ? [m.content] : (m.content || []).filter(p => p.type === 'text').map(p => p.text);
+          const raw = parts.join('\n');
+          if (m.role === 'assistant') { if (raw) last = raw; continue; }
+          if (m.role !== 'user') continue;
+          const bits = [...raw.matchAll(/<(task|feedback|user_message|answer)>([\s\S]*?)<\/\1>/g)].map(x => x[2].trim());
+          const text = bits.join('\n').trim();
+          if (text) out.push({ tool: agent, session: taskId, project: null, ts: Number(taskId) || null, text, context: last.slice(-400) });
+        }
+      }
+    }
+  }
+  return out;
+}

package/src/practice.js

@@ -0,0 +1,119 @@
+// Practice mode: 4 timed mini-games generated from YOUR weaknesses and graded by your own agent.
+import fs from 'node:fs';
+import { askJSON } from './agents.js';
+import { ENGLISH_PATTERNS } from './stats.js';
+
+const bank = JSON.parse(fs.readFileSync(new URL('./bank.json', import.meta.url), 'utf8'));
+const pick = a => a[Math.floor(Math.random() * a.length)];
+const shuffle = a => a.map(v => [Math.random(), v]).sort((x, y) => x[0] - y[0]).map(x => x[1]);
+
+const COACH = 'You are a sharp, kind English-and-prompting coach for software developers (many are non-native English speakers). You design short, fresh exercises and grade honestly. Never reuse textbook examples.';
+
+export async function generateTest({ agent, model, report, stats, worstPrompt }) {
+  const weak = (report?.weaknesses || []).map(w => `- ${w.title}: "${w.example || ''}"`).join('\n');
+  const eng = (report?.english?.errors || []).slice(0, 6).map(e => `- "${e.quote}" → "${e.fix}" (${e.rule})`).join('\n')
+    || (stats?.english?.patterns || []).slice(0, 5).map(p => `- ${p.label}: "${p.example || ''}"`).join('\n');
+  const projects = (stats?.projects || []).slice(0, 4).map(p => p.name).join(', ');
+  if (agent) {
+    try {
+      const t = await askJSON(agent, `${COACH}
+
+TASK: generate_practice
+Seed: ${Math.random().toString(36).slice(2, 8)}
+Their projects: ${projects || 'web apps'}
+Their prompting weaknesses:
+${weak || '- (unknown)'}
+Their English mistakes:
+${eng || '- (none detected)'}
+${worstPrompt ? `One of their real messy prompts (for level 4): "${worstPrompt}"` : ''}
+
+Return ONE JSON object:
+{
+ "passage": {"text":"Level 1: a 4-5 sentence bug/incident report (65-95 words) from a world like theirs, with a clear cause → effect → consequence chain and one concrete number. Shown 45s then hidden.","questions":["what happened?","why?"],"model_answer":"ideal 2-3 sentences","key_facts":["3-4 facts"],"targets":"which weakness"},
+ "fixit": [{"broken":"NEW 12-24 word sentence in broken developer English that reproduces THEIR error patterns","reference":"clean rewrite","focus":"2-4 word hint","targets":"which weakness"}, x3],
+ "diagram": {"title":"a rule/flow from their world","audience":"who to explain it to","boxes":[{"icon":"emoji","label":"max 6 words"}, x3],"model_answer":"one paragraph, exactly 3 sentences, with linking words","targets":"short"},
+ "rewrite": {"original":"${worstPrompt ? 'their real prompt verbatim' : 'an invented messy prompt in their style'}","context":"what that prompt was trying to achieve","model_answer":"an excellent prompt: goal, context, constraints, acceptance criteria","targets":"short"}
+}`, { model, validate: j => { if (!j.passage?.text || (j.fixit || []).length < 3 || (j.diagram?.boxes || []).length < 3) throw new Error('bad test'); } });
+      t.fixit = t.fixit.slice(0, 3); t.diagram.boxes = t.diagram.boxes.slice(0, 3);
+      if (worstPrompt) t.rewrite.original = worstPrompt;
+      t.source = agent;
+      return t;
+    } catch (e) { /* fall through to the offline bank */ }
+  }
+  const p = pick(bank.passages), d = pick(bank.diagrams);
+  return {
+    source: 'offline',
+    passage: { text: p.text, questions: p.questions, key_facts: p.key_facts.map(k => k.fact), model_answer: '', kw: p.key_facts },
+    fixit: shuffle(bank.fixit).slice(0, 3),
+    diagram: { ...d, model_answer: '' },
+    rewrite: { original: worstPrompt || pick(bank.rewrites), context: '', model_answer: '' },
+  };
+}
+
+export function publicTest(t) {
+  return {
+    source: t.source,
+    passage: { text: t.passage.text, questions: t.passage.questions, targets: t.passage.targets || '' },
+    fixit: t.fixit.map(f => ({ broken: f.broken, focus: f.focus || '', targets: f.targets || '' })),
+    diagram: { title: t.diagram.title, audience: t.diagram.audience || 'an end user', boxes: t.diagram.boxes, targets: t.diagram.targets || '' },
+    rewrite: { original: t.rewrite.original, context: t.rewrite.context || '', targets: t.rewrite.targets || '' },
+  };
+}
+
+export async function gradeTest({ agent, model, test, answers }) {
+  if (agent) {
+    try {
+      const r = await askJSON(agent, `${COACH}
+
+TASK: grade_practice
+Grade this timed written-English test (no paste, no spell-check). Empty answer = 0. Copying the passage verbatim loses comprehension marks. A "fix" that keeps the original errors scores low. Quote their exact words. 60 = B1, 75 = B2, 88+ = C1.
+
+${JSON.stringify({
+  level1: { passage: test.passage.text, questions: test.passage.questions, key_facts: test.passage.key_facts, model: test.passage.model_answer, answer: answers.passage },
+  level2: test.fixit.map((f, i) => ({ broken: f.broken, model: f.reference, answer: answers.fixit?.[i] || '' })),
+  level3: { flow: test.diagram.boxes.map(b => b.label), audience: test.diagram.audience, rule: 'one paragraph, exactly 3 sentences', model: test.diagram.model_answer, answer: answers.diagram },
+  level4: { original_prompt: test.rewrite.original, model: test.rewrite.model_answer, answer: answers.rewrite },
+}, null, 1)}
+
+Return ONE JSON object:
+{"criteria":{"sentence_boundaries":{"score":0,"comment":""},"grammar_tense":{"score":0,"comment":""},"comprehension":{"score":0,"comment":""},"clarity":{"score":0,"comment":""}},
+ "levels":{"passage":{"score":0,"feedback":"","mistakes":[{"wrote":"","fix":"","why":""}]},"fixit":{"score":0,"feedback":"","items":[{"score":0,"note":""},{"score":0,"note":""},{"score":0,"note":""}]},"diagram":{"score":0,"feedback":"","mistakes":[]},"rewrite":{"score":0,"feedback":"","mistakes":[]}},
+ "cefr":"A2|B1|B2|C1|C2","verdict":"2 sentences","top_fixes":["3 specific habits"]}`, { model, validate: j => { if (!j.criteria?.grammar_tense) throw new Error('bad grade'); } });
+      return finalize(r, test, answers, agent);
+    } catch (e) { /* offline fallback below */ }
+  }
+  return finalize(offlineGrade(test, answers), test, answers, 'offline');
+}
+
+function finalize(r, test, answers, source) {
+  const c = r.criteria;
+  const n = k => Math.max(0, Math.min(100, Math.round(Number(c[k]?.score) || 0)));
+  const overall = Math.round(0.3 * n('sentence_boundaries') + 0.3 * n('grammar_tense') + 0.25 * n('comprehension') + 0.15 * n('clarity'));
+  return {
+    source, overall, cefr: r.cefr || (overall >= 88 ? 'C1' : overall >= 75 ? 'B2' : overall >= 60 ? 'B1' : 'A2'),
+    criteria: Object.fromEntries(['sentence_boundaries', 'grammar_tense', 'comprehension', 'clarity'].map(k => [k, { score: n(k), comment: c[k]?.comment || '' }])),
+    levels: r.levels || {}, verdict: r.verdict || '', top_fixes: r.top_fixes || [],
+    models: { passage: test.passage.model_answer, fixit: test.fixit.map(f => f.reference), diagram: test.diagram.model_answer, rewrite: test.rewrite.model_answer },
+    test: publicTest(test), answers,
+  };
+}
+
+function offlineGrade(test, a) {
+  const sents = t => (t.trim().match(/[^.!?]+[.!?]+|[^.!?]+$/g) || []).filter(s => s.trim().length > 1);
+  const errs = t => ENGLISH_PATTERNS.reduce((n, [, re]) => n + (re.test(t) ? 1 : 0), 0) + (sents(t).filter(s => /^\s*[a-z]/.test(s)).length);
+  const bound = t => !t.trim() ? 0 : Math.max(0, 100 - (/[.!?]\s*$/.test(t.trim()) ? 0 : 20) - sents(t).filter(s => s.split(/\s+/).length > 30).length * 18);
+  const gram = t => !t.trim() ? 0 : Math.max(0, 100 - errs(t) * 15);
+  const kw = test.passage.kw || [];
+  const lt = (a.passage || '').toLowerCase();
+  const comp = kw.length ? Math.round(100 * kw.filter(k => k.keywords.some(w => lt.includes(w))).length / kw.length) : 50;
+  const all = [a.passage, ...(a.fixit || []), a.diagram, a.rewrite].join(' ');
+  return {
+    criteria: {
+      sentence_boundaries: { score: Math.round((bound(a.passage || '') + bound(a.diagram || '') + bound(a.rewrite || '')) / 3), comment: '' },
+      grammar_tense: { score: gram(all), comment: '' },
+      comprehension: { score: comp, comment: '' },
+      clarity: { score: /\b(if|once|when|after|so|because|then|as a result)\b/i.test(a.diagram || '') ? 75 : 55, comment: '' },
+    },
+    levels: {}, verdict: 'Graded by the basic offline checker. Connect an AI agent for detailed feedback.', top_fixes: [],
+  };
+}

package/src/server.js

@@ -0,0 +1,97 @@
+// Tiny local web server for the report UI. Binds to 127.0.0.1 only and requires a per-run token.
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { generateTest, gradeTest, publicTest } from './practice.js';
+import { history } from './store.js';
+
+const UI = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'ui');
+const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8', '.svg': 'image/svg+xml', '.png': 'image/png', '.json': 'application/json', '.ico': 'image/x-icon' };
+const LEADERBOARD = process.env.HOWAMIPROMPTING_API || 'https://howamiprompting.com/api';
+
+export function startServer({ bundle, prompts, agent, model, port = 0 }) {
+  const token = crypto.randomBytes(16).toString('hex');
+  const tests = new Map();
+
+  const send = (res, code, body, type = 'application/json') => {
+    res.writeHead(code, { 'content-type': type, 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' });
+    res.end(typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body));
+  };
+  const body = req => new Promise((ok, bad) => { let b = ''; req.on('data', d => { b += d; if (b.length > 2e6) req.destroy(); }); req.on('end', () => { try { ok(b ? JSON.parse(b) : {}); } catch (e) { bad(e); } }); });
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      const host = (req.headers.host || '').split(':')[0];
+      if (!['127.0.0.1', 'localhost'].includes(host)) return send(res, 403, { error: 'forbidden' }); // DNS-rebinding guard
+      const url = new URL(req.url, 'http://127.0.0.1');
+      if (url.pathname.startsWith('/api/')) {
+        if (req.headers['x-hap-token'] !== token) return send(res, 401, { error: 'bad token — reopen the link printed in your terminal' });
+        if (url.pathname === '/api/report') return send(res, 200, { ...bundle, history: history() });
+        if (url.pathname === '/api/prompts') {
+          const q = (url.searchParams.get('q') || '').toLowerCase(), tool = url.searchParams.get('tool'), flag = url.searchParams.get('flag');
+          const off = +url.searchParams.get('offset') || 0;
+          let list = prompts;
+          if (tool) list = list.filter(p => p.tool === tool);
+          if (q) list = list.filter(p => p.text.toLowerCase().includes(q));
+          if (flag === 'short') list = list.filter(p => p.words <= 4);
+          if (flag === 'long') list = list.filter(p => p.words >= 80);
+          if (flag === 'paste') list = list.filter(p => p.logLines || p.codeLines);
+          const page = [...list].reverse().slice(off, off + 50).map(({ id, tool, project, ts, text, words }) => ({ id, tool, project, ts, text, words }));
+          return send(res, 200, { total: list.length, items: page });
+        }
+        if (url.pathname === '/api/practice/new' && req.method === 'POST') {
+          const worst = bundle.ai?.makeovers?.[Math.floor(Math.random() * (bundle.ai.makeovers.length || 1))]?.original || bundle.stats?.examples?.vague?.[0] || null;
+          const t = await generateTest({ agent, model, report: bundle.ai, stats: bundle.stats, worstPrompt: worst });
+          const id = crypto.randomBytes(6).toString('hex');
+          tests.set(id, t);
+          return send(res, 200, { id, ...publicTest(t) });
+        }
+        if (url.pathname === '/api/practice/submit' && req.method === 'POST') {
+          const b = await body(req);
+          const t = tests.get(b.id);
+          if (!t) return send(res, 404, { error: 'test expired — start a new one' });
+          return send(res, 200, await gradeTest({ agent, model, test: t, answers: b.answers || {} }));
+        }
+        if (url.pathname === '/api/card' && req.method === 'POST') {
+          // Upload ONLY the rendered share-card PNG (scores, no prompts) to get a public link with a preview image.
+          const b = await body(req);
+          const png = String(b.png || '');
+          if (!png.startsWith('data:image/png;base64,') || png.length > 2.5e6) return send(res, 400, { error: 'Bad image' });
+          const payload = { png, overall: bundle.scores.overall, persona: bundle.stats.persona.name, emoji: bundle.stats.persona.emoji, version: bundle.version };
+          const r = await fetch(LEADERBOARD + '/card.php', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(payload), signal: AbortSignal.timeout(20000) });
+          const j = await r.json().catch(() => ({ error: 'Share service unavailable' }));
+          return send(res, r.ok ? 200 : 502, r.ok ? j : { error: j.error || 'Share service unavailable' });
+        }
+        if (url.pathname === '/api/publish' && req.method === 'POST') {
+          const b = await body(req);
+          const s = bundle.stats, sc = bundle.scores;
+          const payload = {
+            handle: String(b.handle || '').slice(0, 40), github: String(b.github || '').slice(0, 40), country: String(b.country || '').slice(0, 2),
+            overall: sc.overall, scores: sc, persona: s.persona.name, level: bundle.ai?.level || null, ai: !!bundle.ai,
+            prompts: s.totals.prompts, tools: s.tools.map(t => t.name), median_words: s.length.median, version: bundle.version,
+          };
+          const r = await fetch(LEADERBOARD + '/publish.php', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(payload), signal: AbortSignal.timeout(15000) });
+          const j = await r.json().catch(() => ({ error: 'Leaderboard unavailable' }));
+          return send(res, r.ok ? 200 : 502, r.ok ? j : { error: j.error || 'Leaderboard unavailable' });
+        }
+        return send(res, 404, { error: 'not found' });
+      }
+      let p = url.pathname === '/' ? '/index.html' : url.pathname;
+      const file = path.join(UI, path.normalize(p).replace(/^(\.\.[\/\\])+/, ''));
+      if (!file.startsWith(UI) || !fs.existsSync(file)) return send(res, 404, 'not found', 'text/plain');
+      return send(res, 200, fs.readFileSync(file), MIME[path.extname(file)] || 'application/octet-stream');
+    } catch (e) {
+      return send(res, 500, { error: e.message });
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(port, '127.0.0.1', () => {
+      const p = server.address().port;
+      resolve({ server, url: `http://127.0.0.1:${p}/#t=${token}`, port: p, token });
+    });
+  });
+}

package/src/sqlite.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { which } from './util.js';
+
+let nodeSqlite;
+async function loadNodeSqlite() {
+  if (nodeSqlite !== undefined) return nodeSqlite;
+  const orig = process.emitWarning;
+  process.emitWarning = (w, ...a) => { if (String(w).includes('SQLite')) return; return orig.call(process, w, ...a); };
+  try { nodeSqlite = await import('node:sqlite'); } catch { nodeSqlite = null; }
+  process.emitWarning = orig;
+  return nodeSqlite;
+}
+
+/** Copy the DB (+WAL) to a temp dir so we never lock or modify the user's live app DB. */
+function snapshot(dbPath) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hap-'));
+  const dst = path.join(dir, 'db.sqlite');
+  fs.copyFileSync(dbPath, dst);
+  for (const ext of ['-wal', '-shm']) if (fs.existsSync(dbPath + ext)) fs.copyFileSync(dbPath + ext, dst + ext);
+  return { dst, cleanup: () => fs.rmSync(dir, { recursive: true, force: true }) };
+}
+
+/** Run a read-only query. Returns rows (array of objects) or null if SQLite is unavailable. */
+export async function query(dbPath, sql) {
+  let snap;
+  try { snap = snapshot(dbPath); } catch { return null; }
+  try {
+    const mod = await loadNodeSqlite();
+    if (mod?.DatabaseSync) {
+      const db = new mod.DatabaseSync(snap.dst, { readOnly: true });
+      try { return db.prepare(sql).all(); } finally { db.close(); }
+    }
+    if (which('sqlite3')) {
+      const r = spawnSync('sqlite3', ['-readonly', '-json', snap.dst, sql], { encoding: 'utf8', maxBuffer: 1024 * 1024 * 1024 });
+      if (r.status !== 0) return null;
+      return r.stdout.trim() ? JSON.parse(r.stdout) : [];
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    snap.cleanup();
+  }
+}
+
+export async function sqliteAvailable() {
+  return !!((await loadNodeSqlite())?.DatabaseSync || which('sqlite3'));
+}

package/src/stats.js

@@ -0,0 +1,208 @@
+// Local, deterministic metrics — the "Wrapped" layer. No AI needed.
+const STOP = new Set('a an the to of and or in on for with is are be it this that i you me my we our can could would will just please also so then now do does did not no yes ok okay if as at by from but all any some there here what how why when which should make need want like get use using code file files one more see into out up them they its it\'s im i\'m dont don\'t lets let\'s'.split(' '));
+
+const RX = {
+  confirm: /^(y|ya|yes|yeah|yep|yup|ok|okay|k|sure|continue|go|go ahead|proceed|do it|next|yes please|ok do it|looks good|lgtm|perfect|great|nice|cool|thanks|thank you|ty|done|good|correct|right|approved?)[.! ]*$/i,
+  please: /\b(please|pls|plz|kindly)\b/i,
+  thanks: /\b(thanks|thank you|thx|ty|cheers|appreciate)\b/i,
+  sorry: /\b(sorry|my bad|apologies)\b/i,
+  swear: /\b(wtf|wth|ffs|fuck\w*|shit\w*|damn\w*|crap|bullshit|stupid|idiot|dumb|bloody|hell)\b/i,
+  frustr: /(\bstill (not|doesn'?t|isn'?t|broken|failing|the same)\b|\bagain\b.*\b(error|broken|fail|wrong)|\bwhy (is|are|does|did|isn'?t|doesn'?t|would|the hell)\b|\b(doesn'?t|does not|didn'?t|not) work(ing)?\b|\bsame (error|issue|problem|bug)\b|!!+|\?\?+|\bseriously\b|\bcome on\b|\bfor the \w+ time\b|\bi (told|said) you\b|\bwhat the\b)/i,
+  pushback: /^(no|nope|nah|wrong|stop|wait|undo|revert|don'?t|that'?s (not|wrong)|not what|you (broke|deleted|removed|changed)|why did you)\b/i,
+  context: /\b(because|so that|in order to|expected|expect|instead of|currently|right now|the goal|i want|should|must|constraint|requirement|acceptance|without (changing|breaking|touching)|don'?t (change|touch|modify|break)|keep (the|it|existing)|only (change|modify|touch)|for example|e\.g\.|such as|make sure|edge case)\b/i,
+  vagueVerb: /\b(fix( it| this| that)?|broken|doesn'?t work|not working|make it (better|nicer|work|good|look good)|improve (it|this)|clean (it|this) up|do (it|the rest|the same)|same (thing|for)|it'?s wrong|error)\b/i,
+  question: /\?\s*$|^(how|what|why|where|when|which|who|can|could|is|are|does|do|should|would|will)\b/i,
+  multi: /(\balso\b|\band then\b|\bplus\b|^\s*\d+[.)]\s|\n\s*[-*•]\s)/im,
+  canYou: /\b(can|could|would) you\b/i,
+  emoji: /\p{Extended_Pictographic}/gu,
+};
+
+export const ENGLISH_PATTERNS = [
+  ['why because', /\bwhy because\b/i, 'Use just "because".'],
+  ['can able to', /\bcan(not)? able to\b/i, 'Say "can" or "be able to", never both.'],
+  ['didn\'t + past tense', /\b(didn'?t|did not|doesn'?t|does not)\s+(?!need\b|feed\b|proceed\b|exceed\b|succeed\b|embed\b|seed\b|speed\b)(\w+ed|went|came|got|gave|did|made|wrote|took|saw|ran)\b/i, 'After did/does use the base verb: "didn\'t work".'],
+  ['have did / has went', /\b(has|have|had)\s+(went|came|gave|did|wrote|ran|took|saw|ate|broke)\b/i, 'Use the past participle: "have done", "has gone".'],
+  ['missing is/are', /\b(it|this|that|page|api|response|data|button|app|server|screen|value|error|output|code)\s+(not\s+)?(coming|showing|getting|giving|throwing|happening|loading|working|crashing|failing|returning)\b/i, 'Add the helping verb: "the page is showing".'],
+  ['subject–verb agreement', /(?<!\b(?:make|makes|made|making|let|lets|help|helps|see|saw|watch|have|has|had|does|did|do|can|could|will|would|should|must|might|may|to)\s)\b(it|he|she|this|that|user|the user|page|the page|api|button|server|app|code|function|screen)\s+(get|show|work|give|come|take|go|return|throw|crash|load|send|break|fail|run|need|look|seem|have|do)\b(?!['-])/i, 'Singular subjects take -s: "it gets", "the page shows".'],
+  ['a + vowel sound', /\ba\s+(error|api|issue|update|option|object|array|event|input|output|image|endpoint|example|empty|existing|extra|easy|important|hour|ui|id|url|svg|html|sql|ec2)\b/i, 'Use "an" before vowel sounds: "an error", "an API".'],
+  ['double comparative', /\b(more better|more faster|more easier|more simpler|most best|more cleaner)\b/i, '"better", not "more better".'],
+  ['since / for', /\b(since|from)\s+(\d+|two|three|four|five)\s+(mins?|minutes|hours?|days?|weeks?)\b/i, '"for" + duration, "since" + starting point.'],
+  ['redundant words', /\b(discuss about|revert back|return back|repeat again|reply back)\b/i, 'Drop the extra word.'],
+  ['texting shortcuts', /\b(u|ur|pls|plz|thx|bcoz|coz|bcz|wat|wht|r u)\b/i, 'Write words in full — the model does better with clear text.'],
+];
+
+const median = a => { if (!a.length) return 0; const s = [...a].sort((x, y) => x - y); return s[Math.floor(s.length / 2)]; };
+const pct = (n, d) => d ? Math.round(1000 * n / d) / 10 : 0;
+const dayKey = d => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+
+export function computeStats(prompts, { interrupts = 0 } = {}) {
+  const n = prompts.length;
+  const tools = {}, projects = {}, sessions = new Map();
+  const hours = Array(24).fill(0), weekdays = Array(7).fill(0), heat = Array.from({ length: 7 }, () => Array(24).fill(0));
+  const days = new Set();
+  const words = [];
+  const c = { confirm: 0, please: 0, thanks: 0, sorry: 0, swear: 0, frustr: 0, pushback: 0, context: 0, vague: 0, question: 0, multi: 0, canYou: 0, emoji: 0, pastePray: 0, pastedCode: 0, pastedLog: 0, images: 0, lowerStart: 0, noEnd: 0, lowerI: 0, runOn: 0, shouty: 0 };
+  const english = Object.fromEntries(ENGLISH_PATTERNS.map(([k]) => [k, { count: 0, example: null }]));
+  const examples = { swear: [], frustr: [], vague: [], confirm: {}, longest: null, pastePray: [] };
+  const ngrams = new Map(), openers = new Map();
+  const sentenceSessions = new Map();
+  let night = 0, weekend = 0, timed = 0;
+
+  for (const p of prompts) {
+    const prose = p.prose || '';
+    const w = p.words;
+    words.push(w);
+    tools[p.tool] = (tools[p.tool] || 0) + 1;
+    if (p.project) projects[p.project] = (projects[p.project] || 0) + 1;
+    const sk = p.tool + '|' + p.session;
+    if (!sessions.has(sk)) sessions.set(sk, { n: 0, frustr: 0, tool: p.tool, project: p.project, first: p.ts });
+    sessions.get(sk).n++;
+
+    if (p.ts) {
+      const d = new Date(p.ts);
+      timed++;
+      hours[d.getHours()]++; weekdays[d.getDay()]++; heat[d.getDay()][d.getHours()]++;
+      days.add(dayKey(d));
+      if (d.getHours() < 5) night++;
+      if (d.getDay() === 0 || d.getDay() === 6) weekend++;
+    }
+    const t = prose.trim();
+    if (RX.confirm.test(t)) { c.confirm++; const k = t.toLowerCase().replace(/[.! ]+$/, ''); examples.confirm[k] = (examples.confirm[k] || 0) + 1; }
+    if (RX.please.test(t)) c.please++;
+    if (RX.thanks.test(t)) c.thanks++;
+    if (RX.sorry.test(t)) c.sorry++;
+    if (RX.swear.test(t)) { c.swear++; if (examples.swear.length < 5 && w < 40) examples.swear.push(t); }
+    if (RX.frustr.test(t)) { c.frustr++; sessions.get(sk).frustr++; if (examples.frustr.length < 8 && w < 40) examples.frustr.push(t); }
+    if (RX.pushback.test(t)) c.pushback++;
+    if (RX.context.test(t) && w >= 8) c.context++;
+    if (w <= 7 && RX.vagueVerb.test(t) && !p.codeLines && !p.logLines) { c.vague++; if (examples.vague.length < 8) examples.vague.push(t); }
+    if (RX.question.test(t)) c.question++;
+    if (RX.multi.test(p.text) && w > 15) c.multi++;
+    if (RX.canYou.test(t)) c.canYou++;
+    c.emoji += (t.match(RX.emoji) || []).length;
+    if (p.logLines && w < 8) { c.pastePray++; if (examples.pastePray.length < 5) examples.pastePray.push(t || '(just a pasted error)'); }
+    if (p.codeLines) c.pastedCode++;
+    if (p.logLines) c.pastedLog++;
+    c.images += p.images || 0;
+    if (w >= 3) {
+      if (/^[a-z]/.test(t)) c.lowerStart++;
+      if (!/[.!?)"'`:]$/.test(t)) c.noEnd++;
+      if (/(^|\s)i(\s|'m|'ll|'ve|'d)/.test(t)) c.lowerI++;
+      if (t.split(/[.!?;]\s/).some(s => s.split(/\s+/).length > 45)) c.runOn++;
+      const caps = t.match(/\b[A-Z]{3,}\b/g) || [];
+      if (caps.length >= 3 && caps.length / Math.max(1, w) > 0.3) c.shouty++;
+      for (const [k, re] of ENGLISH_PATTERNS) if (re.test(t)) { english[k].count++; if (!english[k].example && w < 60) english[k].example = t.slice(0, 160); }
+    }
+    if (!examples.longest || w > examples.longest.words) examples.longest = { words: w, text: t.slice(0, 280), tool: p.tool, ts: p.ts };
+
+    // phrases
+    const toks = t.toLowerCase().replace(/[^a-z0-9' ]+/g, ' ').split(/\s+/).filter(Boolean);
+    if (toks.length) { const op = toks.slice(0, 2).join(' '); openers.set(op, (openers.get(op) || 0) + 1); }
+    for (let i = 0; i + 1 < toks.length; i++) {
+      for (const len of [2, 3]) {
+        const g = toks.slice(i, i + len);
+        if (g.length < len || STOP.has(g[0]) || STOP.has(g[len - 1])) continue;
+        const k = g.join(' ');
+        ngrams.set(k, (ngrams.get(k) || 0) + 1);
+      }
+    }
+    // repeated instructions (candidates for CLAUDE.md / AGENTS.md / .cursorrules)
+    for (const s of t.split(/(?<=[.!?\n])\s+/)) {
+      const norm = s.toLowerCase().replace(/[^a-z0-9 ]+/g, '').replace(/\s+/g, ' ').trim();
+      const wc = norm.split(' ').length;
+      if (wc < 4 || wc > 22) continue;
+      if (!/\b(always|never|don'?t|do not|use|make sure|avoid|prefer|keep|only|must|should)\b/.test(norm) || RX.pushback.test(norm)) continue;
+      if (!sentenceSessions.has(norm)) sentenceSessions.set(norm, { text: s.trim(), sessions: new Set() });
+      sentenceSessions.get(norm).sessions.add(sk);
+    }
+  }
+
+  // streak
+  const sortedDays = [...days].sort();
+  let streak = 0, cur = 0, prev = null;
+  for (const d of sortedDays) {
+    const t = Date.parse(d);
+    cur = prev && t - prev <= 86400000 * 1.5 ? cur + 1 : 1;
+    streak = Math.max(streak, cur); prev = t;
+  }
+  const sess = [...sessions.values()];
+  const topN = (m, k = 12, min = 2) => [...m.entries()].filter(([, v]) => v >= min).sort((a, b) => b[1] - a[1]).slice(0, k).map(([text, count]) => ({ text, count }));
+  const ratio = k => pct(c[k], n);
+
+  const stats = {
+    totals: {
+      prompts: n, sessions: sessions.size, projects: Object.keys(projects).length, tools: Object.keys(tools).length,
+      words: words.reduce((a, b) => a + b, 0), interrupts,
+      first: prompts.find(p => p.ts)?.ts || null, last: [...prompts].reverse().find(p => p.ts)?.ts || null,
+      activeDays: days.size, longestStreak: streak, avgPerDay: days.size ? Math.round(10 * timed / days.size) / 10 : 0,
+    },
+    tools: Object.entries(tools).sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count, avgWords: Math.round(prompts.filter(p => p.tool === name).reduce((a, p) => a + p.words, 0) / count) })),
+    projects: Object.entries(projects).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count })),
+    time: { hours, weekdays, heat, nightPct: pct(night, timed), weekendPct: pct(weekend, timed), busiestHour: hours.indexOf(Math.max(...hours)), busiestDay: weekdays.indexOf(Math.max(...weekdays)) },
+    length: { avg: n ? Math.round(10 * words.reduce((a, b) => a + b, 0) / n) / 10 : 0, median: median(words), buckets: [[1, 3], [4, 10], [11, 30], [31, 80], [81, 1e9]].map(([a, b]) => words.filter(x => x >= a && x <= b).length), longest: examples.longest },
+    habits: {
+      confirmPct: ratio('confirm'), pleasePct: ratio('please'), thanksPct: ratio('thanks'), sorry: c.sorry,
+      swears: c.swear, swearPct: ratio('swear'), frustrationPct: ratio('frustr'), pushbackPct: ratio('pushback'),
+      contextPct: ratio('context'), vaguePct: ratio('vague'), questionPct: ratio('question'), multiAskPct: ratio('multi'),
+      canYouPct: ratio('canYou'), emoji: c.emoji, pastePrayPct: ratio('pastePray'), pastedCodePct: ratio('pastedCode'), pastedLogPct: ratio('pastedLog'),
+      images: c.images, shoutyPct: ratio('shouty'),
+      topConfirms: Object.entries(examples.confirm).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([text, count]) => ({ text, count })),
+    },
+    english: {
+      lowerStartPct: ratio('lowerStart'), noEndPunctPct: ratio('noEnd'), lowerIPct: ratio('lowerI'), runOnPct: ratio('runOn'),
+      patterns: ENGLISH_PATTERNS.map(([k, , tip]) => ({ label: k, tip, ...english[k] })).filter(x => x.count).sort((a, b) => b.count - a.count),
+    },
+    phrases: dedupeGrams(topN(ngrams, 40, 3)).slice(0, 15),
+    openers: topN(openers, 8, 3),
+    repeated: [...sentenceSessions.values()].filter(x => x.sessions.size >= 3).sort((a, b) => b.sessions.size - a.sessions.size).slice(0, 12).map(x => ({ text: x.text, sessions: x.sessions.size })),
+    sessions: { avgPrompts: sess.length ? Math.round(10 * n / sess.length) / 10 : 0, longest: Math.max(0, ...sess.map(s => s.n)), rageSessions: sess.filter(s => s.frustr >= 3).length },
+    examples: { swear: examples.swear, frustration: examples.frustr, vague: examples.vague, pastePray: examples.pastePray },
+  };
+  stats.heuristic = heuristicScores(stats);
+  stats.persona = persona(stats);
+  return stats;
+}
+
+// drop n-grams contained in a longer, equally frequent n-gram ("dependency injection" vs "use dependency injection")
+function dedupeGrams(list) {
+  return list.filter(a => !list.some(b => b !== a && b.text.includes(a.text) && b.count >= a.count * 0.8) && !list.some(b => b !== a && a.text.includes(b.text) && b.count > a.count * 1.2));
+}
+
+const clamp = v => Math.max(0, Math.min(100, Math.round(v)));
+export function heuristicScores(s) {
+  const h = s.habits, e = s.english, L = s.length;
+  const lenScore = L.median < 4 ? 35 : L.median < 8 ? 55 : L.median < 15 ? 72 : L.median < 60 ? 85 : 75;
+  const clarity = clamp(lenScore - h.vaguePct * 1.2 - h.multiAskPct * 0.3 + 5);
+  const context = clamp(30 + h.contextPct * 1.4 + Math.min(15, h.pastedCodePct * 0.3) - h.pastePrayPct * 1.2);
+  const specificity = clamp(45 + h.contextPct * 0.8 - h.vaguePct * 1.5 - h.confirmPct * 0.3 + (L.median > 12 ? 10 : 0));
+  const efficiency = clamp(88 - h.frustrationPct * 1.6 - h.pushbackPct * 0.9 - h.swearPct * 0.8);
+  const structure = clamp(82 - h.multiAskPct * 0.5 - e.runOnPct * 0.7 - (L.avg > 120 ? 10 : 0) - (L.median < 5 ? 12 : 0));
+  const englishScore = clamp(92 - e.lowerStartPct * 0.12 - e.noEndPunctPct * 0.12 - e.lowerIPct * 0.4 - e.runOnPct * 0.8 - Math.min(30, e.patterns.reduce((a, p) => a + p.count, 0) / Math.max(1, s.totals.prompts) * 220));
+  const overall = clamp(0.2 * clarity + 0.22 * context + 0.18 * specificity + 0.12 * structure + 0.13 * efficiency + 0.15 * englishScore);
+  return { overall, clarity, context, specificity, structure, efficiency, english: englishScore };
+}
+
+const PERSONAS = [
+  { id: 'architect', name: 'The Architect', emoji: '📐', blurb: 'You brief your AI like a senior engineer: goals, constraints, context. It shows.', test: s => s.habits.contextPct / 35 * (s.length.median > 18 ? 1.2 : 0.8) },
+  { id: 'novelist', name: 'The Novelist', emoji: '📜', blurb: 'Your prompts are essays. Rich context — but the important ask sometimes gets buried.', test: s => s.length.avg / 70 },
+  { id: 'sniper', name: 'The Sniper', emoji: '🎯', blurb: 'Short, precise, effective. You say exactly what you need and move on.', test: s => (s.length.median >= 8 && s.length.median <= 25 ? 1 : 0.4) * (1 - s.habits.vaguePct / 30) * (1 - s.habits.frustrationPct / 30) },
+  { id: 'yes', name: 'The Yes-Machine', emoji: '👍', blurb: '"ok", "continue", "yes". You let the agent drive — sometimes straight into a wall.', test: s => s.habits.confirmPct / 22 },
+  { id: 'paste', name: 'The Paste-and-Pray', emoji: '🙏', blurb: 'Error in, fix out. You paste the stack trace and hope. Add one line of context and watch it work.', test: s => s.habits.pastePrayPct / 12 },
+  { id: 'rage', name: 'The Rage Prompter', emoji: '🌋', blurb: 'When the AI messes up, it hears about it. Your frustration is valid — but it costs you turns.', test: s => (s.habits.frustrationPct + s.habits.swearPct * 2) / 16 },
+  { id: 'diplomat', name: 'The Polite Diplomat', emoji: '🎩', blurb: '"Please" and "thank you" — your AI has never felt so respected.', test: s => (s.habits.pleasePct + s.habits.thanksPct) / 30 },
+  { id: 'speedrunner', name: 'The Speedrunner', emoji: '⚡', blurb: 'Three-word prompts at 200 WPM. Fast — but the AI is guessing half the time.', test: s => s.length.median < 7 ? (8 - s.length.median) / 4 : 0 },
+  { id: 'micromanager', name: 'The Micromanager', emoji: '🔍', blurb: '"No, not like that." You course-correct a lot. Front-load the details to skip the back-and-forth.', test: s => s.habits.pushbackPct / 14 },
+];
+export function persona(s) {
+  const ranked = PERSONAS.map(p => ({ ...p, score: p.test(s) || 0 })).sort((a, b) => b.score - a.score);
+  const main = ranked[0];
+  const badges = [];
+  if (s.time.nightPct > 20) badges.push({ emoji: '🦉', label: 'Night Owl', detail: `${s.time.nightPct}% of prompts after midnight` });
+  if (s.time.weekendPct > 30) badges.push({ emoji: '🏖️', label: 'Weekend Warrior', detail: `${s.time.weekendPct}% on weekends` });
+  if (s.totals.longestStreak >= 14) badges.push({ emoji: '🔥', label: 'On Fire', detail: `${s.totals.longestStreak}-day streak` });
+  if (s.tools.length >= 3) badges.push({ emoji: '🧪', label: 'Tool Hopper', detail: `${s.tools.length} different AI tools` });
+  if (s.habits.pleasePct > 20) badges.push({ emoji: '🎩', label: 'Polite', detail: `"please" in ${s.habits.pleasePct}% of prompts` });
+  if (s.habits.swears > 10) badges.push({ emoji: '🤬', label: 'Potty Mouth', detail: `${s.habits.swears} swears` });
+  if (s.totals.prompts > 2000) badges.push({ emoji: '🏋️', label: 'Power User', detail: `${s.totals.prompts.toLocaleString()} prompts` });
+  return { id: main.id, name: main.name, emoji: main.emoji, blurb: main.blurb, runnerUp: ranked[1]?.name, badges };
+}

package/src/store.js

@@ -0,0 +1,24 @@
+// Local history: ~/.howamiprompting/reports/*.json — lets you track your score over time.
+import fs from 'node:fs';
+import path from 'node:path';
+import { dataDir } from './util.js';
+
+const dir = () => { const d = path.join(dataDir(), 'reports'); fs.mkdirSync(d, { recursive: true }); return d; };
+
+export function saveReport(bundle) {
+  const file = path.join(dir(), bundle.generatedAt.replace(/[:.]/g, '-') + '.json');
+  fs.writeFileSync(file, JSON.stringify(bundle));
+  return file;
+}
+
+export function listReports() {
+  return fs.readdirSync(dir()).filter(f => f.endsWith('.json')).sort().map(f => {
+    try { return JSON.parse(fs.readFileSync(path.join(dir(), f), 'utf8')); } catch { return null; }
+  }).filter(Boolean);
+}
+
+export function history() {
+  return listReports().map(r => ({ date: r.generatedAt, overall: r.scores?.overall, scores: r.scores, prompts: r.stats?.totals?.prompts, ai: !!r.ai }));
+}
+
+export const lastReport = () => listReports().pop() || null;