npm - @ygncode/pi-insights - Versions diffs - 1.0.0 - Mend

@ygncode/pi-insights 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/favicon.svg ADDED Viewed

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
+  <path fill="#000" fill-rule="evenodd" d="
+    M165.29 165.29
+    H517.36
+    V400
+    H400
+    V517.36
+    H282.65
+    V634.72
+    H165.29
+    Z
+    M282.65 282.65
+    V400
+    H400
+    V282.65
+    Z
+  "/>
+  <path fill="#000" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
+</svg>

package/dist/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Pi Insights</title>
+    <link rel="icon" type="image/svg+xml" href="./favicon.svg" />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
+    <script type="module" crossorigin src="./assets/index.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/index.ts ADDED Viewed

@@ -0,0 +1,163 @@
+/**
+ * Pi Insights Extension
+ * Generates beautiful analytics reports for pi sessions
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { parseSessionFile } from "./lib/parser.js";
+import { computeAnalytics } from "./lib/analytics.js";
+import type { Analytics } from "./lib/types.js";
+const execAsync = promisify(exec);
+const extensionDir = path.dirname(fileURLToPath(import.meta.url));
+// ── Report Generator ──────────────────────────────────────────────────
+async function ensureBuilt(extensionDir: string): Promise<void> {
+  const distDir = path.join(extensionDir, "dist");
+  const indexHtml = path.join(distDir, "index.html");
+  try {
+    await fs.access(indexHtml);
+    return;
+  } catch {
+    // Need to build
+  }
+  const nodeModules = path.join(extensionDir, "node_modules");
+  try {
+    await fs.access(nodeModules);
+  } catch {
+    await execAsync("npm install", { cwd: extensionDir });
+  }
+  await execAsync("npm run build", { cwd: extensionDir });
+}
+async function generateReport(
+  extensionDir: string,
+  analytics: Analytics,
+  reportDir: string
+): Promise<string> {
+  const distDir = path.join(extensionDir, "dist");
+  const reportPath = path.join(reportDir, "pi-insights.html");
+  const indexPath = path.join(distDir, "index.html");
+  let html = await fs.readFile(indexPath, "utf8");
+  // Inline the favicon as a data URI so it works from file://
+  const faviconPath = path.join(distDir, "favicon.svg");
+  try {
+    const faviconSvg = await fs.readFile(faviconPath, "utf8");
+    const faviconDataUri = "data:image/svg+xml;base64," + Buffer.from(faviconSvg).toString("base64");
+    html = html.replace(/href="\.\/favicon\.svg"/, `href="${faviconDataUri}"`);
+  } catch { /* no favicon, skip */ }
+  // Inline the JS bundle so the file works from file:// without CORS issues
+  const jsMatch = html.match(/<script[^>]*src="\.\/assets\/([^"]*)\.js"[^>]*><\/script>/);
+  if (jsMatch) {
+    const jsFile = path.join(distDir, "assets", jsMatch[1] + ".js");
+    try {
+      const js = await fs.readFile(jsFile, "utf8");
+      // Escape </ so the HTML parser doesn't exit the script block early
+      const safeJs = js.replace(/<\//g, "<\\/");
+      html = html.replace(jsMatch[0], "");
+      html = html.replace(
+        "<div id=\"root\"></div>",
+        () => `<div id="root"></div>\n  <script>\n${safeJs}\n  </script>`
+      );
+    } catch { /* keep original if not found */ }
+  }
+  // Escape </ in the JSON data for the same reason
+  const safeData = JSON.stringify(analytics).replace(/<\//g, "<\\/");
+  html = html.replace("<head>", () => `<head>\n  <script>window.__ANALYTICS_DATA__ = ${safeData};</script>`);
+  await fs.writeFile(reportPath, html, "utf8");
+  return reportPath;
+}
+// ── Main Extension ────────────────────────────────────────────────────
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("insights", {
+    description: "Generate insights report for pi sessions",
+    getArgumentCompletions: () => null,
+    handler: async (_args, ctx) => {
+      const reportDir = path.join(os.homedir(), ".pi", "agent", "insights-reports");
+      await fs.mkdir(reportDir, { recursive: true });
+      ctx.ui.notify("📊 Building UI (first run may take a minute)...", "info");
+      try {
+        await ensureBuilt(extensionDir);
+      } catch (err) {
+        ctx.ui.notify("❌ Build failed: " + (err as Error).message, "error");
+        return;
+      }
+      ctx.ui.notify("📁 Scanning sessions...", "info");
+      const sessionsDir = path.join(os.homedir(), ".pi", "agent", "sessions");
+      const sessionFiles: string[] = [];
+      try {
+        const entries = await fs.readdir(sessionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const subEntries = await fs.readdir(path.join(sessionsDir, entry.name));
+            for (const sub of subEntries) {
+              if (sub.endsWith(".jsonl")) {
+                sessionFiles.push(path.join(sessionsDir, entry.name, sub));
+              }
+            }
+          }
+        }
+      } catch {
+        ctx.ui.notify("❌ Could not find sessions directory", "error");
+        return;
+      }
+      ctx.ui.notify(`📁 Found ${sessionFiles.length} session files`, "info");
+      const sessions = [];
+      let parsed = 0;
+      for (const file of sessionFiles) {
+        const sess = await parseSessionFile(file);
+        if (sess) sessions.push(sess);
+        parsed++;
+        if (parsed % 50 === 0) {
+          ctx.ui.setStatus("insights", `Parsed ${parsed}/${sessionFiles.length}...`);
+        }
+      }
+      if (sessions.length === 0) {
+        ctx.ui.notify("❌ No valid sessions found", "error");
+        return;
+      }
+      ctx.ui.notify(`✅ Parsed ${sessions.length} sessions, generating report...`, "info");
+      const analytics = computeAnalytics(sessions);
+      try {
+        const reportPath = await generateReport(extensionDir, analytics, reportDir);
+        ctx.ui.notify(`🎉 Report ready!`, "info");
+        ctx.ui.setStatus("insights", undefined);
+        try {
+          await execAsync(`open "${reportPath}"`);
+        } catch {
+          ctx.ui.notify("Open manually: " + reportPath, "info");
+        }
+      } catch (err) {
+        ctx.ui.notify("❌ Report generation failed: " + (err as Error).message, "error");
+      }
+    },
+  });
+}

package/lib/analytics.ts ADDED Viewed

@@ -0,0 +1,254 @@
+import type {
+  ParsedSession,
+  Analytics,
+  DailyStats,
+  ProjectStats,
+  ModelStats,
+  RageStats,
+} from "./types.js";
+export function computeAnalytics(sessions: ParsedSession[]): Analytics {
+  if (sessions.length === 0) {
+    return emptyAnalytics();
+  }
+  const sorted = [...sessions].sort((a, b) => a.startTime.getTime() - b.startTime.getTime());
+  const totalSessions = sorted.length;
+  const totalMessages = sorted.reduce((s, sess) => s + sess.messageCount, 0);
+  const totalTokens = sorted.reduce((s, sess) => s + sess.tokenUsage.total, 0);
+  const totalCost = sorted.reduce((s, sess) => s + sess.cost.total, 0);
+  const totalDuration = sorted.reduce((s, sess) => s + sess.duration, 0);
+  const startDate = sorted[0].startTime;
+  const endDate = sorted[sorted.length - 1].endTime;
+  // Daily stats
+  const dailyMap = new Map<string, DailyStats>();
+  for (const sess of sorted) {
+    const date = sess.startTime.toISOString().split("T")[0];
+    const existing = dailyMap.get(date);
+    if (existing) {
+      existing.sessions++;
+      existing.messages += sess.messageCount;
+      existing.tokens += sess.tokenUsage.total;
+      existing.cost += sess.cost.total;
+    } else {
+      dailyMap.set(date, {
+        date,
+        sessions: 1,
+        messages: sess.messageCount,
+        tokens: sess.tokenUsage.total,
+        cost: sess.cost.total,
+      });
+    }
+  }
+  const dailyStats = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date));
+  // Project stats
+  const projectMap = new Map<string, ProjectStats>();
+  for (const sess of sorted) {
+    const existing = projectMap.get(sess.projectName);
+    if (existing) {
+      existing.sessions++;
+      existing.messages += sess.messageCount;
+      existing.tokens += sess.tokenUsage.total;
+      existing.cost += sess.cost.total;
+      existing.duration += sess.duration;
+    } else {
+      projectMap.set(sess.projectName, {
+        name: sess.projectName,
+        sessions: 1,
+        messages: sess.messageCount,
+        tokens: sess.tokenUsage.total,
+        cost: sess.cost.total,
+        duration: sess.duration,
+      });
+    }
+  }
+  const projectStats = Array.from(projectMap.values()).sort((a, b) => b.messages - a.messages);
+  // Model stats
+  const modelMap = new Map<string, ModelStats>();
+  let modelSwitchCount = 0;
+  for (const sess of sorted) {
+    const sessModels = Object.keys(sess.models);
+    if (sessModels.length > 1) modelSwitchCount++;
+    for (const [name, stats] of Object.entries(sess.models)) {
+      const existing = modelMap.get(name);
+      if (existing) {
+        existing.count += stats.count;
+        existing.tokens += stats.tokens;
+        existing.cost += stats.cost;
+      } else {
+        modelMap.set(name, { name, count: stats.count, tokens: stats.tokens, cost: stats.cost, avgDuration: 0 });
+      }
+    }
+  }
+  // Only include models that actually generated tokens (filters model_change-only entries)
+  const modelStats = Array.from(modelMap.values())
+    .filter(m => m.tokens > 0)
+    .sort((a, b) => b.tokens - a.tokens);
+  // Tool usage
+  const toolMap = new Map<string, number>();
+  for (const sess of sorted) {
+    for (const [tool, count] of Object.entries(sess.toolUsage)) {
+      toolMap.set(tool, (toolMap.get(tool) ?? 0) + count);
+    }
+  }
+  const topTools = Array.from(toolMap.entries())
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 10);
+  // Thinking levels
+  const thinkingMap = new Map<string, number>();
+  for (const sess of sorted) {
+    for (const [level, count] of Object.entries(sess.thinkingLevels)) {
+      thinkingMap.set(level, (thinkingMap.get(level) ?? 0) + count);
+    }
+  }
+  const thinkingLevelDistribution = Array.from(thinkingMap.entries())
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count);
+  // Stop reasons
+  const stopMap = new Map<string, number>();
+  for (const sess of sorted) {
+    for (const [reason, count] of Object.entries(sess.stopReasons)) {
+      stopMap.set(reason, (stopMap.get(reason) ?? 0) + count);
+    }
+  }
+  const stopReasonDistribution = Array.from(stopMap.entries())
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count);
+  // Hourly distribution (session start hours)
+  const hourlyMap = new Map<number, number>();
+  for (let i = 0; i < 24; i++) hourlyMap.set(i, 0);
+  for (const sess of sorted) {
+    const hour = sess.startTime.getHours();
+    hourlyMap.set(hour, (hourlyMap.get(hour) ?? 0) + 1);
+  }
+  const hourlyDistribution = Array.from(hourlyMap.entries())
+    .map(([hour, count]) => ({ hour, count }))
+    .sort((a, b) => a.hour - b.hour);
+  // Rage stats
+  const rageByModel = new Map<string, number>();
+  const rageByHour = new Map<number, number>();
+  const rageByProject = new Map<string, number>();
+  const rageByWord = new Map<string, { group: string; count: number }>();
+  let rageTotalHits = 0;
+  let rageMsgsWithSwears = 0;
+  for (const sess of sorted) {
+    const seenMsgKeys = new Set<string>();
+    for (const hit of sess.rageHits) {
+      rageTotalHits++;
+      const msgKey = `${sess.id}-${hit.msgIndex}`;
+      if (!seenMsgKeys.has(msgKey)) {
+        rageMsgsWithSwears++;
+        seenMsgKeys.add(msgKey);
+      }
+      rageByModel.set(hit.model, (rageByModel.get(hit.model) ?? 0) + 1);
+      if (hit.hour >= 0) rageByHour.set(hit.hour, (rageByHour.get(hit.hour) ?? 0) + 1);
+      rageByProject.set(sess.projectName, (rageByProject.get(sess.projectName) ?? 0) + 1);
+      const existing = rageByWord.get(hit.word);
+      if (existing) { existing.count++; }
+      else { rageByWord.set(hit.word, { group: hit.group, count: 1 }); }
+    }
+  }
+  const rageStats: RageStats = {
+    total: rageTotalHits,
+    messagesWithSwears: rageMsgsWithSwears,
+    byModel: Array.from(rageByModel.entries())
+      .map(([name, count]) => ({ name, count }))
+      .sort((a, b) => b.count - a.count),
+    byHour: Array.from({ length: 24 }, (_, h) => ({ hour: h, count: rageByHour.get(h) ?? 0 })),
+    byProject: Array.from(rageByProject.entries())
+      .map(([name, count]) => ({ name, count }))
+      .sort((a, b) => b.count - a.count),
+    topWords: Array.from(rageByWord.entries())
+      .map(([word, { group, count }]) => ({ word, group, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 20),
+  };
+  return {
+    totalSessions,
+    totalMessages,
+    totalTokens,
+    totalCost,
+    totalDuration,
+    avgSessionDuration: Math.round(totalDuration / totalSessions),
+    avgMessagesPerSession: Math.round(totalMessages / totalSessions),
+    dateRange: {
+      start: startDate.toISOString().split("T")[0],
+      end: endDate.toISOString().split("T")[0],
+    },
+    dailyStats,
+    projectStats,
+    modelStats,
+    topTools,
+    thinkingLevelDistribution,
+    stopReasonDistribution,
+    hourlyDistribution,
+    modelSwitchCount,
+    rageStats,
+    sessions: sorted.map(s => ({
+      id: s.id,
+      cwd: s.cwd,
+      projectName: s.projectName,
+      startTime: s.startTime.toISOString(),
+      endTime: s.endTime.toISOString(),
+      duration: s.duration,
+      messageCount: s.messageCount,
+      userMessageCount: s.userMessageCount,
+      assistantMessageCount: s.assistantMessageCount,
+      toolCallCount: s.toolCallCount,
+      tokenUsage: s.tokenUsage,
+      cost: s.cost,
+      models: s.models,
+      providers: s.providers,
+      thinkingLevels: s.thinkingLevels,
+      toolUsage: s.toolUsage,
+      stopReasons: s.stopReasons,
+      toolCallErrors: s.toolCallErrors,
+      hasError: s.hasError,
+    })),
+  };
+}
+function emptyAnalytics(): Analytics {
+  const emptyRage: RageStats = {
+    total: 0,
+    messagesWithSwears: 0,
+    byModel: [],
+    byHour: Array.from({ length: 24 }, (_, h) => ({ hour: h, count: 0 })),
+    byProject: [],
+    topWords: [],
+  };
+  return {
+    totalSessions: 0,
+    totalMessages: 0,
+    totalTokens: 0,
+    totalCost: 0,
+    totalDuration: 0,
+    avgSessionDuration: 0,
+    avgMessagesPerSession: 0,
+    dateRange: { start: "", end: "" },
+    dailyStats: [],
+    projectStats: [],
+    modelStats: [],
+    topTools: [],
+    thinkingLevelDistribution: [],
+    stopReasonDistribution: [],
+    hourlyDistribution: Array.from({ length: 24 }, (_, h) => ({ hour: h, count: 0 })),
+    modelSwitchCount: 0,
+    rageStats: emptyRage,
+    sessions: [],
+  };
+}

package/lib/parser.ts ADDED Viewed

@@ -0,0 +1,185 @@
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import type { ParsedSession, SessionEvent, SessionMessage } from "./types.js";
+import { detectRage } from "./rage.js";
+export async function parseSessionFile(filePath: string): Promise<ParsedSession | null> {
+  try {
+    const stream = createReadStream(filePath, { encoding: "utf8" });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    let sessionId = "";
+    let cwd = "";
+    let startTime: Date | null = null;
+    let endTime: Date | null = null;
+    let userMessages = 0;
+    let assistantMessages = 0;
+    let toolCallCount = 0;
+    let toolCallErrors = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheRead = 0;
+    let totalCacheWrite = 0;
+    let totalTokens = 0;
+    let totalCost = 0;
+    let costInput = 0;
+    let costOutput = 0;
+    let costCacheRead = 0;
+    let costCacheWrite = 0;
+    const models: Record<string, { count: number; tokens: number; cost: number }> = {};
+    const providers: Record<string, number> = {};
+    const thinkingLevels: Record<string, number> = {};
+    const toolUsage: Record<string, number> = {};
+    const stopReasons: Record<string, number> = {};
+    let currentModel = "unknown";
+    const rageHits: ParsedSession["rageHits"] = [];
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line) as SessionEvent;
+        if (!startTime && event.timestamp) startTime = new Date(event.timestamp);
+        if (event.timestamp) endTime = new Date(event.timestamp);
+        if (event.type === "session" || event.type === "session_info") {
+          const data = event as unknown as { id?: string; cwd?: string };
+          if (data.id) sessionId = data.id;
+          if (data.cwd) cwd = data.cwd;
+        }
+        if (event.type === "model_change") {
+          const data = event as unknown as { modelId?: string; provider?: string };
+          if (data.modelId) {
+            models[data.modelId] = models[data.modelId] ?? { count: 0, tokens: 0, cost: 0 };
+            models[data.modelId].count++;
+            currentModel = data.modelId;
+          }
+          if (data.provider) {
+            providers[data.provider] = (providers[data.provider] ?? 0) + 1;
+          }
+        }
+        if (event.type === "thinking_level_change") {
+          const data = event as unknown as { thinkingLevel?: string };
+          if (data.thinkingLevel) {
+            thinkingLevels[data.thinkingLevel] = (thinkingLevels[data.thinkingLevel] ?? 0) + 1;
+          }
+        }
+        if (event.type === "message") {
+          const msg = (event as unknown as { message: SessionMessage }).message;
+          if (msg.role === "user") {
+            userMessages++;
+            // Collect rage hits with the message index for accurate per-message dedup
+            const textParts: string[] = [];
+            if (msg.content) {
+              for (const item of msg.content) {
+                if (item.type === "text" && item.text) textParts.push(item.text);
+              }
+            }
+            const text = textParts.join(" ");
+            if (text) {
+              const hour = event.timestamp ? new Date(event.timestamp).getHours() : -1;
+              for (const hit of detectRage(text)) {
+                rageHits.push({ ...hit, hour, model: currentModel, msgIndex: userMessages });
+              }
+            }
+          } else if (msg.role === "assistant") {
+            assistantMessages++;
+            if (msg.usage) {
+              const input = msg.usage.input ?? 0;
+              const output = msg.usage.output ?? 0;
+              const cacheRead = msg.usage.cacheRead ?? 0;
+              const cacheWrite = msg.usage.cacheWrite ?? 0;
+              const tokens = msg.usage.totalTokens ?? (input + output + cacheRead);
+              const cost = msg.usage.cost?.total ?? 0;
+              totalInput += input;
+              totalOutput += output;
+              totalCacheRead += cacheRead;
+              totalCacheWrite += cacheWrite;
+              totalTokens += tokens;
+              totalCost += cost;
+              costInput += msg.usage.cost?.input ?? 0;
+              costOutput += msg.usage.cost?.output ?? 0;
+              costCacheRead += msg.usage.cost?.cacheRead ?? 0;
+              costCacheWrite += msg.usage.cost?.cacheWrite ?? 0;
+              if (msg.model) {
+                models[msg.model] = models[msg.model] ?? { count: 0, tokens: 0, cost: 0 };
+                models[msg.model].tokens += tokens;
+                models[msg.model].cost += cost;
+              }
+            }
+            if (msg.stopReason) {
+              stopReasons[msg.stopReason] = (stopReasons[msg.stopReason] ?? 0) + 1;
+            }
+          }
+          if (msg.content) {
+            for (const item of msg.content) {
+              if (item.type === "toolCall" && item.name) {
+                toolCallCount++;
+                toolUsage[item.name] = (toolUsage[item.name] ?? 0) + 1;
+              }
+              if (item.type === "toolResult" && item.isError) {
+                toolCallErrors++;
+              }
+            }
+          }
+          if (msg.toolCalls) {
+            toolCallCount += msg.toolCalls.length;
+            for (const tc of msg.toolCalls) {
+              if (tc.name) toolUsage[tc.name] = (toolUsage[tc.name] ?? 0) + 1;
+            }
+          }
+          if (msg.toolResults) {
+            for (const tr of msg.toolResults) {
+              if (tr.isError) toolCallErrors++;
+            }
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+    if (!startTime) return null;
+    if (!endTime) endTime = startTime;
+    const duration = Math.max(1, Math.round((endTime.getTime() - startTime.getTime()) / 60000));
+    const projectName = cwd ? path.basename(cwd) : "unknown";
+    return {
+      id: sessionId || path.basename(filePath, ".jsonl"),
+      cwd,
+      projectName,
+      startTime,
+      endTime,
+      duration,
+      messageCount: userMessages + assistantMessages,
+      userMessageCount: userMessages,
+      assistantMessageCount: assistantMessages,
+      toolCallCount,
+      tokenUsage: { input: totalInput, output: totalOutput, cacheRead: totalCacheRead, cacheWrite: totalCacheWrite, total: totalTokens },
+      cost: { input: costInput, output: costOutput, cacheRead: costCacheRead, cacheWrite: costCacheWrite, total: totalCost },
+      models,
+      providers,
+      thinkingLevels,
+      toolUsage,
+      stopReasons,
+      toolCallErrors,
+      hasError: toolCallErrors > 0,
+      rageHits,
+    };
+  } catch {
+    return null;
+  }
+}

package/lib/rage.ts ADDED Viewed

@@ -0,0 +1,52 @@
+export interface RageWordEntry {
+  word: string;
+  group: string;
+}
+export interface RageMatch {
+  word: string;
+  group: string;
+}
+export const RAGE_WORDLIST: RageWordEntry[] = [
+  { word: "fuck",         group: "fuck"    }, { word: "fucking",      group: "fuck"    },
+  { word: "fucked",       group: "fuck"    }, { word: "fucker",       group: "fuck"    },
+  { word: "motherfucker", group: "fuck"    }, { word: "clusterfuck",  group: "fuck"    },
+  { word: "fuckup",       group: "fuck"    }, { word: "bullshit",     group: "shit"    },
+  { word: "shit",         group: "shit"    }, { word: "shitty",       group: "shit"    },
+  { word: "shithead",     group: "shit"    }, { word: "shithole",     group: "shit"    },
+  { word: "asshole",      group: "ass"     }, { word: "jackass",      group: "ass"     },
+  { word: "dumbass",      group: "ass"     }, { word: "ass",          group: "ass"     },
+  { word: "goddamn",      group: "damn"    }, { word: "goddammit",    group: "damn"    },
+  { word: "dammit",       group: "damn"    }, { word: "damn",         group: "damn"    },
+  { word: "bitches",      group: "bitch"   }, { word: "bitch",        group: "bitch"   },
+  { word: "bastard",      group: "bastard" },
+  { word: "pissed",       group: "piss"    }, { word: "piss",         group: "piss"    },
+  { word: "dickhead",     group: "dick"    }, { word: "dick",         group: "dick"    },
+  { word: "crappy",       group: "crap"    }, { word: "crap",         group: "crap"    },
+  { word: "hell",         group: "hell"    },
+  { word: "wtf",          group: "wtf"     }, { word: "stfu",         group: "stfu"    },
+  { word: "cunt",         group: "cunt"    },
+];
+const PATTERN = new RegExp(
+  `\\b(${RAGE_WORDLIST.map(w => w.word).join("|")})\\b`,
+  "gi"
+);
+const WORD_MAP = new Map<string, string>(
+  RAGE_WORDLIST.map(w => [w.word.toLowerCase(), w.group])
+);
+export function detectRage(text: string): RageMatch[] {
+  const hits: RageMatch[] = [];
+  for (const m of text.toLowerCase().matchAll(PATTERN)) {
+    const group = WORD_MAP.get(m[0]);
+    if (group) hits.push({ word: m[0], group });
+  }
+  return hits;
+}
+export function wordCount(): number {
+  return RAGE_WORDLIST.length;
+}