claude-token-saver 2.0.0

package/src/formatters/table.js

@@ -0,0 +1,235 @@
+/**
+ * Terminal table formatter — zero dependencies.
+ */
+import { ISSUE_MESSAGES } from '../advice.js';
+
+function pad(str, len, align = 'left') {
+  const s = String(str);
+  if (align === 'right') return s.padStart(len);
+  return s.padEnd(len);
+}
+
+function pct(n) {
+  return (n * 100).toFixed(1) + '%';
+}
+
+function millions(n) {
+  return (n / 1_000_000).toFixed(2) + 'M';
+}
+
+function thousands(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + 'K';
+  return String(n);
+}
+
+function hr(len) {
+  return '─'.repeat(len);
+}
+
+function tableRow(cols, widths, aligns) {
+  return (
+    '│ ' +
+    cols.map((c, i) => pad(c, widths[i], aligns[i])).join(' │ ') +
+    ' │'
+  );
+}
+
+function tableSep(widths) {
+  return '├─' + widths.map((w) => hr(w)).join('─┼─') + '─┤';
+}
+
+function tableTop(widths) {
+  return '┌─' + widths.map((w) => hr(w)).join('─┬─') + '─┐';
+}
+
+function tableBot(widths) {
+  return '└─' + widths.map((w) => hr(w)).join('─┴─') + '─┘';
+}
+
+/**
+ * Format the full report for terminal output.
+ */
+function shortSessionId(id) {
+  if (!id) return '(unknown)';
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
+
+function formatContextSize(n) {
+  if (!n) return '0';
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(2) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(0) + 'k';
+  return String(n);
+}
+
+function renderSpikeSection(spikes, contextWindow) {
+  const lines = [];
+  lines.push('  ⚠ 토큰 급증 감지');
+  lines.push(`  ${'─'.repeat(50)}`);
+  if (contextWindow && contextWindow.size === '1M') {
+    lines.push(
+      `  컨텍스트 모드 추정: 1M  (최근 단일 요청 최대 ${formatContextSize(contextWindow.maxContext)} 토큰)`,
+    );
+    lines.push('');
+  }
+  for (const spike of spikes) {
+    const m = spike.metrics;
+    const ratioLabel = spike.ratio ? `${spike.ratio.toFixed(1)}× p95` : 'single-request > 250k';
+    lines.push(
+      `  • ${shortSessionId(m.sessionId)} [${m.projectDir || 'unknown'}]  ` +
+        `총 입력 ${formatContextSize(m.totalInput)}  (${ratioLabel}, 요청 ${m.requestCount}회)`,
+    );
+    if (m.maxContextPerRequest > 0) {
+      lines.push(
+        `      단일 요청 최대 컨텍스트: ${formatContextSize(m.maxContextPerRequest)} 토큰`,
+      );
+    }
+    for (const issue of spike.issues) {
+      const info = ISSUE_MESSAGES[issue.code];
+      if (!info) continue;
+      lines.push(`      · ${info.title}`);
+    }
+    lines.push('');
+  }
+
+  // De-dupe action blocks — if multiple spikes share the same issue, show
+  // the remediation once per run, not once per spike.
+  const seen = new Set();
+  const uniqueIssues = [];
+  for (const spike of spikes) {
+    for (const issue of spike.issues) {
+      if (seen.has(issue.code)) continue;
+      seen.add(issue.code);
+      uniqueIssues.push(issue);
+    }
+  }
+  if (uniqueIssues.length > 0) {
+    lines.push('  권장 액션');
+    lines.push(`  ${'─'.repeat(50)}`);
+    for (const issue of uniqueIssues) {
+      const info = ISSUE_MESSAGES[issue.code];
+      if (!info) continue;
+      lines.push(`  ▸ ${info.title}`);
+      lines.push(`    ${info.explain}`);
+      for (const action of info.actions()) {
+        lines.push(`    - ${action.label}`);
+        for (const cmd of action.commands) {
+          lines.push(`        ${cmd}`);
+        }
+      }
+      lines.push('');
+    }
+  }
+  return lines;
+}
+
+export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow }) {
+  const lines = [];
+
+  // Header
+  lines.push('');
+  lines.push(`  Claude 토큰 아껴쓰기 — Last ${options.days} days`);
+  lines.push(`  (claude-token-saver v${options.version || ''})`.trimEnd());
+  lines.push(`  ${'═'.repeat(50)}`);
+  lines.push('');
+
+  // Spike section goes FIRST — it's what the user acts on.
+  if (spikeReport && spikeReport.spikes.length > 0) {
+    lines.push(...renderSpikeSection(spikeReport.spikes, contextWindow));
+  }
+
+  // Context window chip for the normal case too
+  if (contextWindow && contextWindow.size !== 'unknown') {
+    const note =
+      contextWindow.size === '1M'
+        ? '⚠ 1M 컨텍스트 사용 중 (Opus 4.7+ Max 기본값). 필요 없으면 CLAUDE_CODE_DISABLE_1M_CONTEXT=1'
+        : '✓ 200k 컨텍스트 (표준)';
+    lines.push(`  Context window: ${contextWindow.size}  ${note}`);
+    lines.push(`  (최근 단일 요청 최대 ${formatContextSize(contextWindow.maxContext)} 토큰)`);
+    lines.push('');
+  }
+
+  // Overall summary
+  lines.push('  Summary');
+  lines.push(`  Sessions: ${sum.sessions}  |  API calls: ${sum.apiCalls.toLocaleString()}  |  Model: ${cost.tier}`);
+  lines.push(`  Cache hit rate: ${pct(sum.hitRate)}  |  Total input: ${millions(sum.totalInput)} tokens`);
+  lines.push('');
+
+  // TTL breakdown
+  lines.push('  TTL Breakdown');
+  const ttlW = [18, 16, 16];
+  const ttlA = ['left', 'right', 'right'];
+  lines.push('  ' + tableTop(ttlW));
+  lines.push('  ' + tableRow(['', '5m Ephemeral', '1h Extended'], ttlW, ttlA));
+  lines.push('  ' + tableSep(ttlW));
+  lines.push(
+    '  ' +
+      tableRow(
+        [
+          'Cache writes',
+          `${thousands(ttl.ephemeral5m)} (${pct(ttl.pct5m)})`,
+          `${thousands(ttl.ephemeral1h)} (${pct(ttl.pct1h)})`,
+        ],
+        ttlW,
+        ttlA,
+      ),
+  );
+  lines.push('  ' + tableBot(ttlW));
+  lines.push('');
+
+  // Cost impact
+  lines.push('  Cost Impact (estimated)');
+  const costW = [24, 12];
+  const costA = ['left', 'right'];
+  lines.push('  ' + tableTop(costW));
+  lines.push('  ' + tableRow(['Actual cost', `$${cost.actual}`], costW, costA));
+  lines.push('  ' + tableRow(['Without cache', `$${cost.noCacheCost}`], costW, costA));
+  lines.push('  ' + tableSep(costW));
+  lines.push('  ' + tableRow(['Savings', `$${cost.savings} (${pct(cost.savingsRate)})`], costW, costA));
+  lines.push('  ' + tableRow(['Extra cost if 5m-only', `+$${cost.extraCostIf5m}`], costW, costA));
+  lines.push('  ' + tableBot(costW));
+  lines.push('');
+
+  // Daily trend
+  lines.push('  Daily Trend');
+  const tw = [10, 8, 7, 10, 10, 5];
+  const ta = ['left', 'right', 'right', 'right', 'right', 'right'];
+  lines.push('  ' + tableTop(tw));
+  lines.push('  ' + tableRow(['Date', 'HitRate', 'Calls', 'Read', 'Write', '5m%'], tw, ta));
+  lines.push('  ' + tableSep(tw));
+
+  const recentTrend = trend.slice(-14); // last 14 days
+  for (const d of recentTrend) {
+    const ccTotal = d.ephemeral5m + d.ephemeral1h;
+    const pct5m = ccTotal > 0 ? pct(d.ephemeral5m / ccTotal) : '-';
+    lines.push(
+      '  ' +
+        tableRow(
+          [d.date, pct(d.hitRate), String(d.apiCalls), millions(d.cacheRead), millions(d.cacheCreation), pct5m],
+          tw,
+          ta,
+        ),
+    );
+  }
+  lines.push('  ' + tableBot(tw));
+
+  if (trend.length > 14) {
+    lines.push(`  ... ${trend.length - 14} earlier days omitted (use --format json for full data)`);
+  }
+  lines.push('');
+
+  // Anomalies
+  if (anomalies.length > 0) {
+    lines.push('  ⚠ Anomalies Detected');
+    for (const a of anomalies) {
+      lines.push(
+        `    ${a.date}: hit rate ${pct(a.hitRate)} (7-day avg: ${pct(a.avgHitRate)}, drop: -${pct(a.drop)}) [${a.apiCalls} calls]`,
+      );
+    }
+  } else {
+    lines.push('  ✓ No anomalies detected');
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}

package/src/hook-manager.js

@@ -0,0 +1,89 @@
+/**
+ * Install/uninstall the SessionEnd hook in ~/.claude/settings.json
+ */
+
+import { readFile, writeFile, copyFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const HOOK_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'hook.cjs');
+const HOOK_DEST = join(homedir(), '.claude', 'cache-monitor-hook.cjs');
+const HOOK_MARKER = 'cache-monitor-hook';
+
+export async function installHook({ threshold = 0.7 } = {}) {
+  // Copy hook script to ~/.claude/ for stable path
+  await copyFile(HOOK_SCRIPT, HOOK_DEST);
+
+  let settings;
+  try {
+    const raw = await readFile(SETTINGS_PATH, 'utf8');
+    settings = JSON.parse(raw);
+  } catch {
+    settings = {};
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.PostToolUse)) settings.hooks.PostToolUse = [];
+
+  // Remove existing cache-monitor hook if present
+  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
+    (h) => {
+      // Check nested hooks structure
+      const nested = h.hooks || [];
+      return !nested.some((nh) => nh.command?.includes(HOOK_MARKER));
+    },
+  );
+
+  // Add new hook (correct 3-level nested structure)
+  // Normalize path separators for Windows compatibility in shell commands
+  const hookPath = HOOK_DEST.replace(/\\/g, '/');
+  settings.hooks.PostToolUse.push({
+    matcher: 'Bash|Edit|Write',
+    hooks: [
+      {
+        type: 'command',
+        command: `node "${hookPath}" --threshold ${threshold}`,
+        timeout: 10,
+      },
+    ],
+  });
+
+  await writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+
+  console.log(`✓ Hook installed at ${HOOK_DEST}`);
+  console.log(`  Settings updated: ${SETTINGS_PATH}`);
+  console.log(`  Threshold: ${(threshold * 100).toFixed(0)}%`);
+  console.log(`  Stats file: ~/.claude/cache-stats.jsonl`);
+}
+
+export async function uninstallHook() {
+  let settings;
+  try {
+    const raw = await readFile(SETTINGS_PATH, 'utf8');
+    settings = JSON.parse(raw);
+  } catch {
+    console.log('No settings.json found, nothing to uninstall.');
+    return;
+  }
+
+  if (settings.hooks?.PostToolUse) {
+    const before = settings.hooks.PostToolUse.length;
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
+      (h) => {
+        const nested = h.hooks || [];
+        return !nested.some((nh) => nh.command?.includes(HOOK_MARKER));
+      },
+    );
+    const removed = before - settings.hooks.PostToolUse.length;
+
+    if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+    await writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    console.log(`✓ Removed ${removed} hook(s) from settings.json`);
+  } else {
+    console.log('No cache-monitor hook found in settings.');
+  }
+}

package/src/hook.cjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Claude Code PostToolUse hook — standalone, zero dependencies, CommonJS.
+ * Appends per-session cache stats to ~/.claude/cache-stats.jsonl.
+ * Warns if hit rate drops below threshold.
+ *
+ * Written in CommonJS so it works standalone in ~/.claude/ without package.json.
+ *
+ * Receives hook context on stdin:
+ *   { session_id, transcript_path, cwd, tool_name, tool_input, tool_response }
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const STATS_FILE = path.join(os.homedir(), '.claude', 'cache-stats.jsonl');
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+
+// Parse threshold from args
+let threshold = 0.7;
+const thIdx = process.argv.indexOf('--threshold');
+if (thIdx !== -1 && process.argv[thIdx + 1]) {
+  threshold = parseFloat(process.argv[thIdx + 1]);
+}
+
+// Read stdin (hook context)
+let stdin = '';
+try {
+  stdin = fs.readFileSync(0, 'utf8');
+} catch {
+  // no stdin
+}
+
+let context;
+try {
+  context = JSON.parse(stdin);
+} catch {
+  process.exit(0);
+}
+
+const sessionId = context.session_id;
+const cwd = context.cwd || '';
+if (!sessionId) process.exit(0);
+
+// Resolve session file: prefer transcript_path, fallback to directory scan
+function resolveSessionFile() {
+  // Method 1: transcript_path (Claude Code v2.1.85+)
+  if (context.transcript_path) {
+    try {
+      fs.statSync(context.transcript_path);
+      return context.transcript_path;
+    } catch {
+      // path provided but file not found, try fallback
+    }
+  }
+
+  // Method 2: scan projects directory (older versions)
+  try {
+    const dirs = fs.readdirSync(PROJECTS_DIR);
+    for (const d of dirs) {
+      const fp = path.join(PROJECTS_DIR, d, `${sessionId}.jsonl`);
+      try {
+        fs.statSync(fp);
+        return fp;
+      } catch {
+        // not here
+      }
+    }
+  } catch {
+    // no projects dir
+  }
+
+  return null;
+}
+
+const sessionFile = resolveSessionFile();
+if (!sessionFile) process.exit(0);
+
+// Parse session file
+let content;
+try {
+  content = fs.readFileSync(sessionFile, 'utf8');
+} catch {
+  process.exit(0);
+}
+
+const lines = content.trim().split('\n');
+const requests = new Map();
+
+for (const line of lines) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    continue;
+  }
+
+  const msg = entry.message;
+  if (!msg || !msg.usage || !msg.id) continue;
+
+  const u = msg.usage;
+  const cc = u.cache_creation || {};
+  const reqId = entry.requestId || msg.id;
+
+  requests.set(reqId, {
+    input: u.input_tokens || 0,
+    cacheCreation: u.cache_creation_input_tokens || 0,
+    cacheRead: u.cache_read_input_tokens || 0,
+    ephemeral5m: cc.ephemeral_5m_input_tokens || 0,
+    ephemeral1h: cc.ephemeral_1h_input_tokens || 0,
+    output: u.output_tokens || 0,
+    model: msg.model || 'unknown',
+  });
+}
+
+if (requests.size === 0) process.exit(0);
+
+const reqs = Array.from(requests.values());
+const totals = reqs.reduce(
+  function (a, r) {
+    a.input += r.input;
+    a.cacheCreation += r.cacheCreation;
+    a.cacheRead += r.cacheRead;
+    a.ephemeral5m += r.ephemeral5m;
+    a.ephemeral1h += r.ephemeral1h;
+    a.output += r.output;
+    return a;
+  },
+  { input: 0, cacheCreation: 0, cacheRead: 0, ephemeral5m: 0, ephemeral1h: 0, output: 0 },
+);
+
+const totalInput = totals.cacheRead + totals.cacheCreation + totals.input;
+const hitRate = totalInput > 0 ? totals.cacheRead / totalInput : 0;
+
+const record = {
+  timestamp: new Date().toISOString(),
+  sessionId: sessionId,
+  cwd: cwd,
+  apiCalls: requests.size,
+  hitRate: Math.round(hitRate * 10000) / 10000,
+  tokens: {
+    input: totals.input,
+    cacheCreation: totals.cacheCreation,
+    cacheRead: totals.cacheRead,
+    ephemeral5m: totals.ephemeral5m,
+    ephemeral1h: totals.ephemeral1h,
+    output: totals.output,
+  },
+  model: reqs[0] ? reqs[0].model : 'unknown',
+};
+
+// Append to stats file
+try {
+  fs.appendFileSync(STATS_FILE, JSON.stringify(record) + '\n', 'utf8');
+} catch {
+  // can't write, ignore
+}
+
+// Alert if hit rate below threshold
+if (hitRate < threshold && requests.size >= 5) {
+  var pct = (hitRate * 100).toFixed(1);
+  var ccTotal = totals.ephemeral5m + totals.ephemeral1h;
+  var pct5m = ccTotal > 0 ? ((totals.ephemeral5m / ccTotal) * 100).toFixed(0) : '0';
+  process.stdout.write(
+    '\u26a0 Cache hit rate: ' + pct + '% (threshold: ' + (threshold * 100).toFixed(0) + '%) | 5m TTL: ' + pct5m + '% | ' + requests.size + ' API calls\n',
+  );
+}

package/src/parser.js

@@ -0,0 +1,197 @@
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { join, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+
+const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
+
+/**
+ * Parse a single session JSONL file.
+ * Deduplicates by requestId (last-write-wins for streaming chunks).
+ */
+export async function parseSessionFile(filePath) {
+  const requests = new Map();
+  let sessionId = null;
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const ts = entry.timestamp;
+    if (ts) {
+      if (!firstTimestamp || ts < firstTimestamp) firstTimestamp = ts;
+      if (!lastTimestamp || ts > lastTimestamp) lastTimestamp = ts;
+    }
+
+    if (!sessionId && entry.sessionId) {
+      sessionId = entry.sessionId;
+    }
+
+    const msg = entry.message;
+    if (!msg?.usage || !msg.id) continue;
+
+    const usage = msg.usage;
+    const cc = usage.cache_creation || {};
+    const reqId = entry.requestId || msg.id;
+
+    requests.set(reqId, {
+      requestId: reqId,
+      model: msg.model || 'unknown',
+      inputTokens: usage.input_tokens || 0,
+      cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+      cacheReadTokens: usage.cache_read_input_tokens || 0,
+      ephemeral5mTokens: cc.ephemeral_5m_input_tokens || 0,
+      ephemeral1hTokens: cc.ephemeral_1h_input_tokens || 0,
+      outputTokens: usage.output_tokens || 0,
+    });
+  }
+
+  const reqs = [...requests.values()];
+  let maxContextPerRequest = 0;
+  const totals = reqs.reduce(
+    (acc, r) => {
+      acc.input += r.inputTokens;
+      acc.cacheCreation += r.cacheCreationTokens;
+      acc.cacheRead += r.cacheReadTokens;
+      acc.ephemeral5m += r.ephemeral5mTokens;
+      acc.ephemeral1h += r.ephemeral1hTokens;
+      acc.output += r.outputTokens;
+      const ctx = r.inputTokens + r.cacheCreationTokens + r.cacheReadTokens;
+      if (ctx > maxContextPerRequest) maxContextPerRequest = ctx;
+      return acc;
+    },
+    { input: 0, cacheCreation: 0, cacheRead: 0, ephemeral5m: 0, ephemeral1h: 0, output: 0 },
+  );
+
+  return {
+    sessionId,
+    filePath,
+    startTime: firstTimestamp ? new Date(firstTimestamp) : null,
+    endTime: lastTimestamp ? new Date(lastTimestamp) : null,
+    requestCount: reqs.length,
+    requests: reqs,
+    totals,
+    maxContextPerRequest,
+    model: reqs[0]?.model || 'unknown',
+  };
+}
+
+/**
+ * Find the most recent user-message timestamp in a session JSONL.
+ * Used for statusline mode so the agent's own tool calls don't reset the TTL
+ * countdown — only the user's actual prompts (type === "user") do.
+ *
+ * @param {string} filePath absolute path to the session JSONL
+ * @returns {Promise<Date|null>}
+ */
+export async function getLastUserMessageTime(filePath) {
+  let lastUserTs = null;
+  try {
+    const rl = createInterface({
+      input: createReadStream(filePath, { encoding: 'utf8' }),
+      crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'user' && entry.timestamp) {
+          lastUserTs = entry.timestamp;
+        }
+      } catch {
+        // ignore malformed lines
+      }
+    }
+  } catch {
+    return null;
+  }
+  return lastUserTs ? new Date(lastUserTs) : null;
+}
+
+/**
+ * Discover all session JSONL files under ~/.claude/projects/
+ */
+export async function discoverSessionFiles(options = {}) {
+  const { projectFilter, days = 30, excludeSessionPath } = options;
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  const files = [];
+  // Resolve the excluded session to an absolute path so equality checks are exact.
+  // Use path.isAbsolute() so Windows paths like C:\... are recognized too.
+  const excludeAbs = excludeSessionPath
+    ? (isAbsolute(excludeSessionPath) ? excludeSessionPath : join(process.cwd(), excludeSessionPath))
+    : null;
+
+  let projectDirs;
+  try {
+    projectDirs = await readdir(CLAUDE_DIR);
+  } catch {
+    return files;
+  }
+
+  for (const projDir of projectDirs) {
+    if (projectFilter && !projDir.includes(projectFilter)) continue;
+
+    const projPath = join(CLAUDE_DIR, projDir);
+    let entries;
+    try {
+      entries = await readdir(projPath);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.endsWith('.jsonl')) continue;
+      const fp = join(projPath, entry);
+      if (excludeAbs && fp === excludeAbs) continue;
+      try {
+        const s = await stat(fp);
+        if (s.mtimeMs >= cutoff) {
+          files.push({ path: fp, projectDir: projDir, mtime: s.mtimeMs });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return files.sort((a, b) => a.mtime - b.mtime);
+}
+
+/**
+ * Parse all sessions with concurrency control
+ */
+export async function parseAllSessions(options = {}) {
+  const files = await discoverSessionFiles(options);
+  const concurrency = 10;
+  const results = [];
+
+  for (let i = 0; i < files.length; i += concurrency) {
+    const batch = files.slice(i, i + concurrency);
+    const parsed = await Promise.all(
+      batch.map(async (f) => {
+        try {
+          const session = await parseSessionFile(f.path);
+          session.projectDir = f.projectDir;
+          return session;
+        } catch {
+          return null;
+        }
+      }),
+    );
+    results.push(...parsed.filter(Boolean));
+  }
+
+  return results.filter((s) => s.requestCount > 0);
+}