skalpel 3.4.6 → 3.4.7

package/prosumer-hooks/skalpel-statusline.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// skalpel statusline — reads the running "time saved" counter (bumped by skalpel-hook.mjs every time
+// a real recurring pattern fires) and prints one line for Claude Code's status bar. Brave's
+// ads-blocked-counter, but for AI-coding thrash. Fail-open: no stats yet -> print nothing.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const STATS_PATH = join(homedir(), ".skalpel", "stats.json");
+const STEER_PATH = join(homedir(), ".skalpel", "steer.json");
+
+// ANSI — the status bar renders color. Emphasize the WIN (time saved) in green; show the live steer
+// in accent; recede the secondary numbers so the eye lands on saved-time + what skalpel's doing now.
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+function main() {
+  let s;
+  try {
+    s = JSON.parse(readFileSync(STATS_PATH, "utf8"));
+  } catch {
+    return; // no stats yet — print nothing rather than a misleading "0 saved"
+  }
+  const sess = (s.session_hours || 0).toFixed(1);
+  const total = (s.total_hours || 0).toFixed(1);
+  const steers = s.total_events || 0;
+
+  // The LIVE steer (written by skalpel-hook.mjs each turn) — the deterministic awareness channel: the
+  // user SEES skalpel steering right now, even when the model doesn't surface a 🔬 line in the answer.
+  let steerLabel = null;
+  let creditMins = null;
+  try {
+    const st = JSON.parse(readFileSync(STEER_PATH, "utf8"));
+    steerLabel = st?.label || null;
+    creditMins = st?.credit || null;
+  } catch {
+    /* no steer/credit this turn — just show the counter */
+  }
+  // The felt "just delivered" tick — the +Xmin the n+1 check credited THIS turn. Hero position, bold
+  // green, right after the wordmark: you SEE it land, then it folds into the growing total.
+  // the per-turn tick sits to the RIGHT of the running total: total = the accumulation, tick = what
+  // THIS turn just added. Both green (the win).
+  const tick = creditMins ? ` · ${BOLD}${GREEN}+${creditMins} min saved this turn${RESET}` : "";
+  // Animate the steering label so it reads as LIVE — Claude Code re-invokes the statusline periodically,
+  // so a time-derived frame cycles a small spinner. (A single-line status bar can't move text vertically;
+  // this is the alive-feeling equivalent.) Only spins while a steer is on the board.
+  const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  const frame = FRAMES[Math.floor(Date.now() / 120) % FRAMES.length];
+  const steering = steerLabel ? ` · ${CYAN}${frame} steering: ${steerLabel}${RESET}` : "";
+
+  // LIVE session tally — how many loops skalpel has caught THIS session (peak-end: the "end" number
+  // stays visible so the user sees it before they quit, even though the recap itself lands next start).
+  void sess;
+  process.stdout.write(
+    `${BOLD}skalpel${RESET}${steering} · ${GREEN}~${total}h saved${RESET}${tick} · ${DIM}${steers} steers${RESET}`,
+  );
+}
+
+main();

package/prosumer-hooks/stats.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// stats.mjs — fold ~/.skalpel/metrics.ndjson into a counter hashtable + latency view, so you can see
+// injection success/failure (inject rate) vs cold-start failure (cold-abort rate) at a glance.
+// Usage:  node ~/.skalpel/hooks/stats.mjs            (all time)
+//         node ~/.skalpel/hooks/stats.mjs --since 24h (last N h/m/d)
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const PATH = join(homedir(), ".skalpel", "metrics.ndjson");
+
+function sinceMs(arg) {
+  const m = /^(\d+)([hmd])$/.exec(arg || "");
+  if (!m) return 0;
+  const n = +m[1];
+  return n * { m: 60e3, h: 3600e3, d: 86400e3 }[m[2]];
+}
+const sinceArgIdx = process.argv.indexOf("--since");
+const window = sinceArgIdx > -1 ? sinceMs(process.argv[sinceArgIdx + 1]) : 0;
+const cutoff = window ? Date.now() - window : 0;
+
+let lines = [];
+try {
+  lines = readFileSync(PATH, "utf8").trim().split("\n").filter(Boolean);
+} catch {
+  console.log("no metrics yet (" + PATH + ")");
+  process.exit(0);
+}
+
+// counter hashtable: { prompt: {inject: n, silent: n, abort: n, ...}, session: {...} }
+const counts = {};
+const lat = {}; // event -> [ms, ...] for non-null ms
+let total = 0;
+for (const line of lines) {
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    continue;
+  }
+  if (cutoff && new Date(e.ts).getTime() < cutoff) continue;
+  total++;
+  (counts[e.event] ||= {})[e.outcome] = ((counts[e.event] ||= {})[e.outcome] || 0) + 1;
+  if (typeof e.ms === "number") (lat[e.event] ||= []).push(e.ms);
+}
+
+function pct(arr, p) {
+  if (!arr.length) return null;
+  const s = [...arr].sort((a, b) => a - b);
+  return s[Math.min(s.length - 1, Math.floor((p / 100) * s.length))];
+}
+
+const label = window ? `last ${process.argv[sinceArgIdx + 1]}` : "all time";
+console.log(`\nskalpel injection telemetry — ${label} — ${total} events\n`);
+for (const ev of Object.keys(counts)) {
+  const c = counts[ev];
+  const n = Object.values(c).reduce((a, b) => a + b, 0);
+  const ok = c.inject || 0;
+  const cold = c.abort || 0;
+  console.log(`■ ${ev}  (${n})`);
+  for (const [k, v] of Object.entries(c).sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${k.padEnd(14)} ${String(v).padStart(5)}  ${((100 * v) / n).toFixed(1)}%`);
+  }
+  const L = lat[ev] || [];
+  if (L.length) {
+    console.log(
+      `    latency        p50=${pct(L, 50)}ms  p95=${pct(L, 95)}ms  max=${Math.max(...L)}ms`,
+    );
+  }
+  console.log(
+    `    → inject rate ${((100 * ok) / n).toFixed(1)}%   cold-abort rate ${((100 * cold) / n).toFixed(1)}%\n`,
+  );
+}