claude-memory-admin 1.6.0 → 1.8.0

package/public/views/rtk.mjs

@@ -0,0 +1,146 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+
+const compact = (value) => {
+  const rounded = Math.round(value);
+  if (Math.abs(rounded) >= 1000000) return `${(rounded / 1000000).toFixed(1)}M`;
+  if (Math.abs(rounded) >= 1000) return `${(rounded / 1000).toFixed(1)}K`;
+  return String(rounded);
+};
+
+const clamp = (percent) => Math.min(100, Math.max(0, percent));
+
+const fact = (value, label) => node('span', {}, [
+  node('b', { class: ui.meterFactValue, text: value }),
+  document.createTextNode(` ${label}`),
+]);
+
+function meter(percent, unit, note, facts) {
+  return node('div', { class: ui.meter }, [
+    node('div', { class: ui.meterTop }, [
+      node('span', { class: ui.meterValue, text: `${percent.toFixed(1)}%` }),
+      node('span', { class: ui.meterUnit, text: unit }),
+    ]),
+    node('div', { class: ui.meterBar }, [
+      node('div', { class: ui.meterFill('accent'), style: `width:${clamp(percent).toFixed(1)}%` }),
+    ]),
+    note ? node('p', { class: ui.meterNote, text: note }) : null,
+    facts.length ? node('div', { class: ui.meterFacts }, facts) : null,
+  ]);
+}
+
+function projectSection(report) {
+  const project = report.project;
+  if (!project) return [];
+  if (!project.commands) {
+    return [
+      node('div', { class: ui.sectionLabel, text: 'This project' }),
+      node('p', { class: ui.noteTight, text: `rtk has filtered nothing in ${report.projectDir} yet.` }),
+    ];
+  }
+  return [node('div', { class: ui.sectionLabel, text: 'This project' }), meter(
+    project.savedPct,
+    'of what rtk read in this project never reached the model',
+    'rtk scopes its ledger by working directory, so this covers every command run from this project path.',
+    [
+      fact(compact(project.saved), 'tokens saved'),
+      fact(compact(project.commands), 'commands filtered'),
+      fact(`${compact(project.input)} → ${compact(project.output)}`, 'in / out'),
+      fact(`${compact(project.avgMs)}ms`, 'average'),
+    ],
+  )];
+}
+
+function machineMeter(report) {
+  const machine = report.machine;
+  if (!machine) return null;
+  const window = machine.window;
+  const facts = [
+    fact(compact(machine.saved), 'tokens saved'),
+    fact(compact(machine.commands), 'commands filtered'),
+    fact(`${compact(machine.avgMs)}ms`, 'average'),
+  ];
+  if (window && window.commands) {
+    facts.push(fact(`${compact(window.saved)} (${window.savedPct.toFixed(1)}%)`, `saved in the last ${window.days} days`));
+  }
+  return meter(
+    machine.savedPct,
+    'of everything rtk has ever filtered on this machine',
+    null,
+    facts,
+  );
+}
+
+function missedRow(item) {
+  const saving = `${compact(item.savedTokens)} tokens (${item.savedPct.toFixed(0)}%)`;
+  return node('div', { class: ui.issue(false) }, [
+    node('div', { class: ui.issueBody }, [
+      node('div', { class: ui.issueTitle, text: `${item.command} ran ${item.count.toLocaleString()} times unfiltered` }),
+      node('div', { class: ui.issueDetail, text: `${item.equivalent} would have saved about ${saving}` }),
+    ]),
+    node('span', { class: ui.badge('neutral'), text: item.category || 'Other' }),
+  ]);
+}
+
+function discoverSection(report) {
+  const discover = report.discover;
+  if (!discover || !discover.commands) return [];
+
+  const parts = [
+    node('div', { class: ui.sectionLabel, text: 'Left on the table' }),
+    meter(
+      discover.adoptionPct,
+      `of the commands in the last ${discover.sinceDays} days already went through rtk`,
+      `Counted across ${discover.sessionsScanned.toLocaleString()} session transcripts for this project.`,
+      [
+        fact(discover.alreadyRtk.toLocaleString(), 'already filtered'),
+        fact(discover.commands.toLocaleString(), 'commands seen'),
+        fact(discover.sessionsScanned.toLocaleString(), 'sessions scanned'),
+      ],
+    ),
+  ];
+
+  if (!discover.missed.length) {
+    parts.push(node('p', { class: ui.okLine, text: 'Nothing rtk knows how to filter was run raw.' }));
+    return parts;
+  }
+
+  for (const item of discover.missed) parts.push(missedRow(item));
+  const hidden = discover.missedTotal - discover.missed.length;
+  const left = hidden === 1 ? '1 smaller one is not shown' : `${hidden} smaller ones are not shown`;
+  parts.push(node('p', { class: ui.note, text: hidden > 0
+    ? `Estimates from rtk itself, worst first; ${left}. They count what the filter would have stripped, not what the model would have ignored.`
+    : 'Estimates from rtk itself, worst first. They count what the filter would have stripped, not what the model would have ignored.' }));
+  return parts;
+}
+
+function errorNotes(report) {
+  if (!report.errors.length) return [];
+  return [
+    node('div', { class: ui.sectionLabel, text: 'Not read' }),
+    ...report.errors.map((error) => node('p', { class: ui.noteTight, text: `${error.step}: ${error.message}` })),
+  ];
+}
+
+export function rtkSummary(report) {
+  const project = report.project;
+  if (project && project.commands) {
+    return `${project.savedPct.toFixed(1)}% saved here · ${compact(project.saved)} tokens`;
+  }
+  if (report.machine) return `${report.machine.savedPct.toFixed(1)}% saved on this machine`;
+  return 'no ledger';
+}
+
+export function renderRtk(container, report) {
+  for (const part of projectSection(report)) container.append(part);
+
+  container.append(node('div', { class: ui.sectionLabel, text: report.project ? 'Every project' : 'This machine' }));
+  const machine = machineMeter(report);
+  container.append(machine || node('p', { class: ui.noteTight, text: 'The machine-wide ledger could not be read.' }));
+  if (!report.project && !report.projectDir) {
+    container.append(node('p', { class: ui.note, text: 'This entry is the user scope rather than a project, so rtk has no working directory to slice its ledger by.' }));
+  }
+
+  for (const part of discoverSection(report)) container.append(part);
+  for (const part of errorNotes(report)) container.append(part);
+}

package/public/views/sessions.mjs

@@ -5,6 +5,8 @@ import { state } from '/state.mjs';
 import { sizeLabel, sessionDate, isAt } from '/parts.mjs';
 import { selectMemory } from '/store.mjs';
 import { paint } from '/bus.mjs';
+import { goTo } from '/parts.mjs';
+import { toast } from '/api.mjs';
 
 const TITLE_SOURCE = {
   'ai-title': 'title Claude Code generated for this session',
@@ -12,9 +14,15 @@ const TITLE_SOURCE = {
   prompt: 'first prompt, no generated title found in the part read',
 };
 
-function sessionRow(session, memoriesFrom) {
+export function focusSession(id) {
+  state.aux.sessionFocus = id;
+  state.aux.sessionDay = null;
+  goTo('environment', 'sessions');
+}
+
+function sessionRow(session, memoriesFrom, focused) {
   const soon = session.expiresInDays !== null && session.expiresInDays <= 7;
-  const caret = node('span', { class: ui.contextCaret, text: '\u25b8' });
+  const caret = node('span', { class: ui.contextCaret, text: focused ? '\u25be' : '\u25b8' });
 
   const tags = [];
   if (session.gitBranch) tags.push(node('span', { class: ui.badge('neutral'), text: session.gitBranch }));
@@ -29,7 +37,7 @@ function sessionRow(session, memoriesFrom) {
     tags.push(node('span', { class: ui.badge('project'), text: memory.name }));
   }
 
-  const body = node('div', { class: ui.contextBody, hidden: true });
+  const body = node('div', { class: ui.contextBody, hidden: !focused });
   const facts = node('dl', { class: ui.metaList });
   const rows = [
     ['session', session.id],
@@ -62,7 +70,7 @@ function sessionRow(session, memoriesFrom) {
 
   const button = node('button', {
     class: ui.contextRowButton,
-    'aria-expanded': 'false',
+    'aria-expanded': String(Boolean(focused)),
     onclick: (event) => {
       const open = body.hidden;
       body.hidden = !open;
@@ -227,9 +235,21 @@ export async function renderSessions(container) {
     }));
   }
   container.append(listHead);
+  const focus = state.aux.sessionFocus;
+  state.aux.sessionFocus = null;
+
   const card = node('div', { class: ui.card });
+  let focused = null;
   for (const session of visible) {
-    card.append(sessionRow(session, byOrigin.get(session.id) || []));
+    const row = sessionRow(session, byOrigin.get(session.id) || [], session.id === focus);
+    if (session.id === focus) focused = row;
+    card.append(row);
   }
   container.append(card);
+
+  if (focus && focused) {
+    requestAnimationFrame(() => focused.scrollIntoView({ block: 'center' }));
+  } else if (focus) {
+    toast('That transcript is no longer beside this store - Claude Code has swept it.');
+  }
 }

package/public/views/tools.mjs

@@ -0,0 +1,144 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { isAt } from '/parts.mjs';
+import { paint } from '/bus.mjs';
+import { renderRtk, rtkSummary } from '/views/rtk.mjs';
+import { renderCcusage, ccusageSummary } from '/views/ccusage.mjs';
+
+const OPT_IN = 'toolsOptIn';
+
+const PANELS = {
+  rtk: { render: renderRtk, summary: rtkSummary },
+  ccusage: { render: renderCcusage, summary: ccusageSummary },
+};
+
+const installed = () => state.tools.filter((tool) => tool.found && PANELS[tool.id]);
+
+const openKey = (id) => `toolOpen:${id}`;
+const isOpen = (id) => localStorage.getItem(openKey(id)) === '1';
+
+function setOpen(id, open) {
+  if (open) localStorage.setItem(openKey(id), '1');
+  else localStorage.removeItem(openKey(id));
+}
+
+async function fetchTool(id) {
+  const storeId = state.storeId;
+  let next;
+  try {
+    next = { data: await api(`/api/stores/${encodeURIComponent(storeId)}/tools/${encodeURIComponent(id)}`) };
+  } catch (err) {
+    next = { error: err.message };
+  }
+  if (state.storeId !== storeId) return;
+  state.aux.tools = { ...state.aux.tools, [id]: next };
+  if (isAt('environment', 'tools')) paint('tab');
+}
+
+function start({ remember = true } = {}) {
+  if (remember) localStorage.setItem(OPT_IN, '1');
+  const running = {};
+  for (const tool of installed()) running[tool.id] = { running: true };
+  state.aux.tools = running;
+  for (const tool of installed()) fetchTool(tool.id);
+}
+
+function readAll() {
+  start();
+  paint('tab');
+}
+
+function turnOff() {
+  localStorage.removeItem(OPT_IN);
+  state.aux.tools = null;
+  paint('tab');
+}
+
+function gate(container, tools) {
+  const names = tools.map((tool) => tool.label).join(' and ');
+  const verb = tools.length > 1 ? 'are installed' : 'is installed';
+  container.append(node('div', { class: ui.issue(false) }, [
+    node('div', { class: ui.issueBody }, [
+      node('div', { class: ui.issueTitle, text: `${names} ${verb}, and not being read` }),
+      node('div', { class: ui.issueDetail, text: `Each keeps a ledger of what it saved or spent on your behalf. Reading them runs ${names} on this machine, so it stays off until you ask.` }),
+    ]),
+    node('button', { class: ui.buttonSmall, text: 'Read tool stats', onclick: readAll }),
+  ]));
+}
+
+function headline(tool, slot) {
+  if (!slot || slot.running) return 'reading…';
+  if (slot.error) return 'could not be read';
+  return PANELS[tool.id].summary(slot.data);
+}
+
+function subtitle(tool, slot) {
+  const report = slot && slot.data;
+  if (report && report.version) return `${tool.label} ${report.version}`;
+  return tool.label;
+}
+
+function body(tool, slot) {
+  const host = node('div');
+  if (!slot || slot.running) {
+    host.append(node('p', { class: ui.note, text: `Reading the ${tool.label} ledger…` }));
+    return host;
+  }
+  if (slot.error) {
+    host.append(node('div', { class: ui.issue(true) }, [
+      node('div', { class: ui.issueBody }, [
+        node('div', { class: ui.issueTitle, text: `${tool.label} could not be read` }),
+        node('div', { class: ui.issueDetail, text: slot.error }),
+      ]),
+      node('button', { class: ui.buttonSmall, text: 'Try again', onclick: readAll }),
+    ]));
+    return host;
+  }
+  PANELS[tool.id].render(host, slot.data);
+  return host;
+}
+
+function accordion(container, tool, slot) {
+  const open = isOpen(tool.id);
+  const panel = body(tool, slot);
+  panel.hidden = !open;
+
+  const caret = node('span', { class: ui.contextCaret, text: open ? '▾' : '▸' });
+
+  container.append(node('button', {
+    class: ui.contextRowButton,
+    'aria-expanded': String(open),
+    onclick: (event) => {
+      const next = panel.hidden;
+      panel.hidden = !next;
+      caret.textContent = next ? '▾' : '▸';
+      event.currentTarget.setAttribute('aria-expanded', String(next));
+      setOpen(tool.id, next);
+    },
+  }, [
+    node('div', { class: ui.contextMain }, [
+      node('div', { class: ui.contextFile }, [caret, document.createTextNode(subtitle(tool, slot))]),
+    ]),
+    node('div', { class: ui.contextSize, text: headline(tool, slot) }),
+  ]));
+  container.append(panel);
+}
+
+export function renderTools(container) {
+  const tools = installed();
+  if (!tools.length) return;
+
+  if (!state.aux.tools && localStorage.getItem(OPT_IN) === '1') start({ remember: false });
+  if (!state.aux.tools) return gate(container, tools);
+
+  container.append(node('div', { class: ui.listBar }, [
+    node('span', { class: ui.sectionLabelInline, text: 'Companion tools' }),
+    node('span', { class: ui.listSpacer }),
+    node('button', { class: ui.buttonSmall, text: 'Re-read', onclick: readAll }),
+    node('button', { class: ui.buttonSmall, text: 'Turn off', onclick: turnOff }),
+  ]));
+
+  for (const tool of tools) accordion(container, tool, state.aux.tools[tool.id]);
+}

package/server.mjs

@@ -16,6 +16,7 @@ import { listStores } from './src/stores.mjs';
 import { forgetPath, rememberPath } from './src/pathcache.mjs';
 import { searchAll } from './src/search.mjs';
 import { verifyPaths } from './src/pathcheck.mjs';
+import { detectTools, toolReport } from './src/tools.mjs';
 import { sessionsWithSummaries, transcriptDir } from './src/sessions.mjs';
 import {
   addIndexEntry,
@@ -128,6 +129,14 @@ function requireStore(id) {
   return store;
 }
 
+const VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version || null;
+  } catch {
+    return null;
+  }
+})();
+
 function storeProjectDir(store) {
   // The global store is the user scope itself, which no project owns.
   if (store.kind === 'global') return null;
@@ -217,6 +226,8 @@ async function handleApi(req, res, url) {
       rootSource: origin.path === ROOT ? origin.source : 'flag',
       rootFile: origin.path === ROOT ? origin.file : null,
       rootWarning: origin.invalid,
+      version: VERSION,
+      tools: detectTools(),
       stores: listStores(ROOT),
     });
   }
@@ -276,6 +287,14 @@ async function handleApi(req, res, url) {
     return sendJson(res, 200, sessionsWithSummaries(slugDir, { projectDir: storeProjectDir(store) }));
   }
 
+  if (action.startsWith('tools/') && req.method === 'GET') {
+    const target = {
+      projectDir: store.kind === 'global' ? null : storeProjectDir(store),
+      slug: store.kind === 'auto' ? store.slug : null,
+    };
+    return sendJson(res, 200, await toolReport(action.slice('tools/'.length), target));
+  }
+
   if (action === 'settings' && req.method === 'GET') {
     return sendJson(res, 200, settingsReport({ projectDir: storeProjectDir(store) }));
   }

package/src/ccusage.mjs

@@ -0,0 +1,122 @@
+import os from 'node:os';
+
+import { collector, findBinary, num, parseJson, pct, runBinary, text } from './toolrun.mjs';
+
+const BINARY = 'ccusage';
+const WINDOW_DAYS = 30;
+const SESSION_LIMIT = 8;
+const MODEL_LIMIT = 6;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+export const findCcusage = (env = process.env) => ({ id: BINARY, ...findBinary(BINARY, env) });
+
+const runCcusage = (args, options) => runBinary(BINARY, args, options);
+
+const ZERO = { sessions: 0, cost: 0, tokens: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+function rowOf(session) {
+  const models = Array.isArray(session.modelBreakdowns) ? session.modelBreakdowns : [];
+  return {
+    id: text(session.sessionId),
+    slug: text(session.projectPath),
+    cost: num(session.totalCost),
+    tokens: num(session.totalTokens),
+    input: num(session.inputTokens),
+    output: num(session.outputTokens),
+    cacheRead: num(session.cacheReadTokens),
+    cacheWrite: num(session.cacheCreationTokens),
+    last: text(session.lastActivity),
+    models: models
+      .filter((model) => model && typeof model === 'object')
+      .map((model) => ({ name: text(model.modelName), cost: num(model.cost), tokens: num(model.outputTokens) }))
+      .filter((model) => model.name),
+  };
+}
+
+const totalsOf = (rows) => rows.reduce((sum, row) => ({
+  sessions: sum.sessions + 1,
+  cost: sum.cost + row.cost,
+  tokens: sum.tokens + row.tokens,
+  input: sum.input + row.input,
+  output: sum.output + row.output,
+  cacheRead: sum.cacheRead + row.cacheRead,
+  cacheWrite: sum.cacheWrite + row.cacheWrite,
+}), ZERO);
+
+function modelMix(rows) {
+  const byName = new Map();
+  for (const row of rows) {
+    for (const model of row.models) {
+      const seen = byName.get(model.name) || { name: model.name, cost: 0, tokens: 0 };
+      seen.cost += model.cost;
+      seen.tokens += model.tokens;
+      byName.set(model.name, seen);
+    }
+  }
+  return [...byName.values()].sort((a, b) => b.cost - a.cost).slice(0, MODEL_LIMIT);
+}
+
+function windowOf(rows, now) {
+  const cutoff = now - (WINDOW_DAYS * DAY_MS);
+  const recent = rows.filter((row) => {
+    const stamp = Date.parse(row.last);
+    return Number.isFinite(stamp) && stamp >= cutoff;
+  });
+  return { days: WINDOW_DAYS, ...totalsOf(recent) };
+}
+
+function machineOf(raw, rows) {
+  const totals = raw && typeof raw.totals === 'object' && raw.totals ? raw.totals : {};
+  return {
+    sessions: rows.length,
+    cost: num(totals.totalCost),
+    tokens: num(totals.totalTokens),
+    input: num(totals.inputTokens),
+    output: num(totals.outputTokens),
+    cacheRead: num(totals.cacheReadTokens),
+    cacheWrite: num(totals.cacheCreationTokens),
+  };
+}
+
+export async function ccusageReport(target = {}, { run = runCcusage, home = os.homedir(), now = Date.now() } = {}) {
+  const { errors, step } = collector();
+
+  const [version, raw] = await Promise.all([
+    step('version', async () => text(await run(['--version'], { cwd: home })).trim().replace(/^ccusage\s+/, '')),
+    step('claude session', async () => parseJson(
+      await run(['claude', 'session', '--json', '--offline'], { cwd: home }),
+      'ccusage claude session',
+    )),
+  ]);
+
+  if (!raw) {
+    return { tool: BINARY, version: version || null, slug: target.slug || null, machine: null, project: null, errors };
+  }
+
+  const rows = (Array.isArray(raw.sessions) ? raw.sessions : [])
+    .filter((session) => session && typeof session === 'object')
+    .map(rowOf)
+    .filter((row) => row.id);
+
+  const machine = machineOf(raw, rows);
+  const mine = target.slug ? rows.filter((row) => row.slug === target.slug) : null;
+  const mineTotals = mine ? totalsOf(mine) : null;
+
+  return {
+    tool: BINARY,
+    version: version || null,
+    slug: target.slug || null,
+    machine: { ...machine, window: windowOf(rows, now) },
+    project: mine ? {
+      ...mineTotals,
+      share: pct(mineTotals.cost, machine.cost),
+      window: windowOf(mine, now),
+      models: modelMix(mine),
+      top: [...mine]
+        .sort((a, b) => b.cost - a.cost)
+        .slice(0, SESSION_LIMIT)
+        .map(({ id, cost, tokens, last }) => ({ id, cost, tokens, last })),
+    } : null,
+    errors,
+  };
+}

package/src/rtk.mjs

@@ -0,0 +1,111 @@
+import os from 'node:os';
+
+import { collector, findBinary, num, parseJson, pct, runBinary, text, usableDir } from './toolrun.mjs';
+
+const BINARY = 'rtk';
+const DISCOVER_DAYS = 30;
+const DISCOVER_LIMIT = 10;
+const MISSED_LIMIT = 12;
+const TREND_DAYS = 30;
+
+export const findRtk = (env = process.env) => ({ id: BINARY, ...findBinary(BINARY, env) });
+
+const runRtk = (args, options) => runBinary(BINARY, args, options);
+
+function summaryOf(raw) {
+  const summary = raw && typeof raw.summary === 'object' && raw.summary ? raw.summary : {};
+  return {
+    commands: num(summary.total_commands),
+    input: num(summary.total_input),
+    output: num(summary.total_output),
+    saved: num(summary.total_saved),
+    savedPct: num(summary.avg_savings_pct),
+    totalMs: num(summary.total_time_ms),
+    avgMs: num(summary.avg_time_ms),
+  };
+}
+
+function daysOf(raw) {
+  const list = raw && Array.isArray(raw.daily) ? raw.daily : [];
+  return list
+    .filter((day) => day && typeof day === 'object')
+    .map((day) => ({
+      date: text(day.date),
+      commands: num(day.commands),
+      input: num(day.input_tokens),
+      saved: num(day.saved_tokens),
+      savedPct: num(day.savings_pct),
+    }))
+    .filter((day) => day.date);
+}
+
+function windowOf(days, count) {
+  const recent = days.slice(-count);
+  const totals = recent.reduce((sum, day) => ({
+    commands: sum.commands + day.commands,
+    input: sum.input + day.input,
+    saved: sum.saved + day.saved,
+  }), { commands: 0, input: 0, saved: 0 });
+  return {
+    days: count,
+    active: recent.length,
+    commands: totals.commands,
+    saved: totals.saved,
+    savedPct: pct(totals.saved, totals.input),
+  };
+}
+
+function discoverOf(raw) {
+  const commands = num(raw.total_commands);
+  const alreadyRtk = num(raw.already_rtk);
+  const supported = Array.isArray(raw.supported) ? raw.supported : [];
+  const missed = supported
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => ({
+      command: text(item.command),
+      count: num(item.count),
+      equivalent: text(item.rtk_equivalent),
+      category: text(item.category),
+      savedTokens: num(item.estimated_savings_tokens),
+      savedPct: num(item.estimated_savings_pct),
+    }))
+    .filter((item) => item.command)
+    .sort((a, b) => b.savedTokens - a.savedTokens);
+
+  return {
+    sessionsScanned: num(raw.sessions_scanned),
+    commands,
+    alreadyRtk,
+    adoptionPct: pct(alreadyRtk, commands),
+    sinceDays: num(raw.since_days) || DISCOVER_DAYS,
+    missedTotal: missed.length,
+    missed: missed.slice(0, MISSED_LIMIT),
+  };
+}
+
+export async function rtkReport(target = {}, { run = runRtk, home = os.homedir() } = {}) {
+  const { errors, step } = collector();
+  const dir = usableDir(target.projectDir);
+
+  const [version, machine, project, discover] = await Promise.all([
+    step('version', async () => text(await run(['--version'], { cwd: home })).trim().replace(/^rtk\s+/, '')),
+    step('gain', async () => parseJson(await run(['gain', '-a', '--format', 'json'], { cwd: home }), 'rtk gain')),
+    dir ? step('gain --project', async () => parseJson(await run(['gain', '-p', '--format', 'json'], { cwd: dir }), 'rtk gain --project')) : null,
+    dir ? step('discover', async () => parseJson(
+      await run(['discover', '--format', 'json', '-s', String(DISCOVER_DAYS), '-l', String(DISCOVER_LIMIT)], { cwd: dir }),
+      'rtk discover',
+    )) : null,
+  ]);
+
+  const days = daysOf(machine);
+
+  return {
+    tool: BINARY,
+    version: version || null,
+    projectDir: dir,
+    machine: machine ? { ...summaryOf(machine), days, window: windowOf(days, TREND_DAYS) } : null,
+    project: project ? summaryOf(project) : null,
+    discover: discover ? discoverOf(discover) : null,
+    errors,
+  };
+}