shakers-cli 0.0.0-stage → 0.14.0

package/src/usage-repo-scope.js

@@ -0,0 +1,162 @@
+'use strict';
+
+// Repo-scoping for the `ai-usage` command, extracted from bin/ai-usage.js (structure refactor, issue 020).
+
+const { isRefusedWalkRoot } = require('./scan-exclusions');
+const {
+  detectRepos,
+  repoIdentityForCwd,
+  matchReposByFlag,
+  scopeFromSelection,
+  indexOfCurrentRepo,
+} = require('./detect-repos');
+const { promptSelect } = require('./prompt-select');
+const { createStdinAsk } = require('./stdin-ask');
+
+const MAX_MACHINE_WIDE_REPOS = 5;
+const SCOPE_MACHINE = 'machine';
+const SCOPE_REPO = 'repo';
+
+function currentRepoToplevel(cwd, repoIdentityFn = repoIdentityForCwd) {
+  try {
+    return repoIdentityFn(cwd).toplevel || cwd;
+  } catch {
+    return cwd;
+  }
+}
+
+// The real git toplevel of `cwd`, or null when `cwd` is not a repo (or is a refused system root like `/`, the MCP `cwd=/` case).
+function cwdRepoToplevel(cwd, repoIdentityFn = repoIdentityForCwd) {
+  if (isRefusedWalkRoot(cwd)) return null;
+  try {
+    return repoIdentityFn(cwd).toplevel || null;
+  } catch {
+    return null;
+  }
+}
+
+// Pure: builds the machine-wide root set.
+function machineWideToplevels(cwdRepoTop, detectedRepos, cap = MAX_MACHINE_WIDE_REPOS) {
+  const ordered = [];
+  const seen = new Set();
+  const push = (t) => {
+    if (typeof t !== 'string' || !t) return;
+    if (isRefusedWalkRoot(t)) return;
+    if (seen.has(t)) return;
+    seen.add(t);
+    ordered.push(t);
+  };
+  push(cwdRepoTop);
+  for (const r of detectedRepos || []) push(r && r.toplevel);
+  const capped = ordered.slice(0, cap);
+  return { toplevels: capped, total: ordered.length, capped: ordered.length > capped.length };
+}
+
+function cwdOnlyScope(repos, cwdToplevel) {
+  const idx = indexOfCurrentRepo(repos, cwdToplevel);
+  if (idx === -1) {
+    return { selectedCwds: new Set(), toplevels: [cwdToplevel], mode: 'cwd' };
+  }
+  const { selectedCwds, selectedToplevels } = scopeFromSelection(repos, [idx]);
+  return {
+    selectedCwds,
+    toplevels: selectedToplevels.length ? selectedToplevels : [cwdToplevel],
+    mode: 'cwd',
+  };
+}
+
+async function promptScope({ catalog, stdinIsTTY = true, mkAsk = createStdinAsk } = {}) {
+  const c = (catalog && catalog.cli) || {};
+  const items = [
+    { key: SCOPE_MACHINE, label: c.reposScopeOptionMachine || 'Whole machine' },
+    { key: SCOPE_REPO, label: c.reposScopeOptionRepo || 'Current repo' },
+  ];
+  const ask = mkAsk();
+  try {
+    const picked = await promptSelect({
+      ask,
+      stdinIsTTY,
+      out: (s) => process.stdout.write(`${s}\n`),
+      items,
+      labelFor: (it) => it.label,
+      header: c.reposScopePromptHeader || '',
+      hint: c.reposScopePromptHint || '',
+    });
+    return picked ? picked.key : null;
+  } finally {
+    if (ask && typeof ask.close === 'function') ask.close();
+  }
+}
+
+// Resolve which repos feed the AI-usage evaluation.
+async function resolveRepoScope({
+  opts,
+  cwd,
+  injectedAsk,
+  catalog,
+  detectReposFn = detectRepos,
+  repoIdentityFn = repoIdentityForCwd,
+  chooseScope = promptScope,
+  isTTY = !!process.stdin.isTTY && !!process.stdout.isTTY,
+}) {
+  const cwdToplevel = currentRepoToplevel(cwd, repoIdentityFn);
+  const cwdRepoTop = cwdRepoToplevel(cwd, repoIdentityFn);
+  const note = (s) => {
+    if (!opts.json) process.stdout.write(`\n  ${s}\n`);
+  };
+
+  const detect = () => {
+    try {
+      return detectReposFn(process.env);
+    } catch {
+      return { repos: [], unassignedSessionCount: 0 };
+    }
+  };
+
+  // 1. Explicit repo list always wins.
+  if (opts.repos) {
+    const { repos, unassignedSessionCount } = detect();
+    note(catalog.cli.reposDetectedNote(repos.length, unassignedSessionCount));
+    const { indices, unmatched } = matchReposByFlag(repos, opts.repos);
+    if (unmatched.length > 0) {
+      process.stderr.write(`  ${catalog.cli.reposFlagUnmatched(unmatched.join(', '))}\n`);
+    }
+    if (indices.length > 0) {
+      const { selectedCwds, selectedToplevels } = scopeFromSelection(repos, indices);
+      return { selectedCwds, toplevels: [...new Set(selectedToplevels)], mode: 'flag' };
+    }
+    return cwdOnlyScope(repos, cwdToplevel);
+  }
+
+  const wantsMachine = opts.allRepos || opts.machine || opts.scope === SCOPE_MACHINE;
+  const wantsRepo = opts.repo || opts.scope === SCOPE_REPO;
+
+  let choice = null;
+  if (wantsMachine) choice = SCOPE_MACHINE;
+  else if (wantsRepo) choice = SCOPE_REPO;
+  else if (isTTY && !injectedAsk && !opts.json) {
+    choice = await chooseScope({ catalog, stdinIsTTY: true });
+  }
+  if (choice === null) choice = SCOPE_REPO;
+
+  if (choice === SCOPE_MACHINE) {
+    const { repos, unassignedSessionCount } = detect();
+    note(catalog.cli.reposDetectedNote(repos.length, unassignedSessionCount));
+    const mw = machineWideToplevels(cwdRepoTop, repos);
+    if (mw.capped) {
+      process.stderr.write(`\n  ${catalog.cli.reposScopeCapped(mw.toplevels.length, mw.total)}\n`);
+    }
+    note(catalog.cli.reposScopeAll);
+    return {
+      selectedCwds: null,
+      toplevels: mw.toplevels.length ? mw.toplevels : [cwdToplevel],
+      mode: 'all',
+    };
+  }
+
+  // Current repo.
+  const { repos } = detect();
+  return cwdOnlyScope(repos, cwdToplevel);
+}
+
+module.exports = { resolveRepoScope, machineWideToplevels, promptScope };

package/src/usage-run-steps.js

@@ -0,0 +1,354 @@
+'use strict';
+
+const { scan, scanForRoots } = require('./scanner');
+const { classify } = require('./maturity');
+const { renderTerminal } = require('./render-terminal');
+const { reportGateForIdentity } = require('./report-gating');
+const { revealText } = require('./typewriter');
+const { persistFootprint } = require('./report-store');
+const {
+  loadConsentState,
+  getConsentDecision,
+  recordConsent,
+  isValidEmail,
+  normalizeEmail,
+  autoShare,
+  consentPath,
+} = require('./share');
+const { runConsentPrompt } = require('./consent-flow');
+const { createStdinAsk } = require('./stdin-ask');
+const {
+  parseAgentDescriptions,
+  parseAgentOrgChartForRoots,
+  parseAgentDescriptionsForRoots,
+  parseAgentDefinitionsForRoots,
+} = require('./agent-org-chart');
+const { collectAgentUsage } = require('./agent-usage');
+const { collectSessionSignals } = require('./session-signals');
+const {
+  collectScopedGitActivity,
+  collectScopedWorkStreams,
+  collectScopedDetectionEvidence,
+} = require('./scope-signals');
+const { detectAuthorshipMismatch } = require('./authorship-mismatch');
+const { MODEL_CALL, REASON, skipped, attachModelCall } = require('./model-call-record');
+const {
+  getSynthesisEndpoint,
+  getRoadmapEndpoint,
+  getAgentEvaluationEndpoint,
+  getAiProfileEndpoint,
+} = require('./config');
+// "My work with AI" preview, read from the hub ai-profile (same as the front).
+const { resolveAiProfilePreview } = require('./ai-profile-preview');
+const { renderAiProfileTerminal } = require('./render-ai-fluency');
+const { ensureFreshSession } = require('./session-refresh');
+const { loadAuthSession, sessionStatus } = require('./auth-session-store');
+const { c: termColors } = require('./terminal-format');
+const { withStaticStatus, withSpinner } = require('./terminal-progress');
+const { computeConsentSkip } = require('./consent-skip');
+const { getRoadmapEntry } = require('./roadmap-content');
+const {
+  maybeSynthesizeAgents,
+  maybeEvaluateAgents,
+  maybePersonalizeRoadmap,
+} = require('./usage-model-calls');
+const { doBuildNextLevel } = require('./usage-oneshot-commands');
+
+// Automatic, silent PERSISTING once consent is `granted` (ADR-007, gating revised by ADR-011: consent controls persistence only, never what's shown).
+async function maybeAutoShare(report, maturity, root, catalog, { bypassThrottle = false } = {}) {
+  try {
+    const result = await autoShare(report, maturity, { root, bypassThrottle });
+    if (result && result.ok && result.backend) {
+      process.stdout.write(`  ${catalog.backendChain.saved(result.backend)}\n`);
+      return result;
+    }
+    // Surface why a send was skipped/failed (user-language, stderr); null = quiet.
+    if (result && result.reason) {
+      const msg = catalog.sendStatus.reason(result.reason);
+      if (msg) process.stderr.write(`  ${sendStatusColor(result.reason)}${msg}${termColors.reset}\n`);
+    }
+    return result || { ok: false, reason: null };
+  } catch {
+    try {
+      const msg = catalog.sendStatus.reason('error');
+      if (msg) process.stderr.write(`  ${termColors.danger}${msg}${termColors.reset}\n`);
+    } catch { /* never break the local report over a notice */ }
+    return { ok: false, reason: 'error' };
+  }
+}
+
+const SEND_WARN_REASONS = new Set(['throttled', 'email-unverified', 'no-email', 'no-endpoint-configured']);
+function sendStatusColor(reason) {
+  return SEND_WARN_REASONS.has(reason) ? termColors.warning : termColors.danger;
+}
+
+function performScan({ opts, catalog }) {
+  const root = opts.root;
+  const report = withStaticStatus(catalog.cli.scanningLabel, () => scan({ root }));
+  // `let`, not `const`: this is the cwd tier.
+  const maturity = classify(report);
+
+  if (Array.isArray(report.agents) && report.agents.length > 0) {
+    report.agentDescriptions = parseAgentDescriptions(root || process.cwd());
+  }
+
+  return { report, maturity, root, rootDir: root || process.cwd() };
+}
+
+// The identity gate + local (no-network, no-LLM) agent-usage signal.
+function prepareIdentityAndUsage({ report, catalog, quiet = false }) {
+  const hasAgents = Array.isArray(report.agents) && report.agents.length > 0;
+  const gate = reportGateForIdentity();
+
+  // --json owns stdout: one parseable document, and the MCP's JSON-RPC channel.
+  if (gate.showFrameworkIntro && !quiet) process.stdout.write(`\n  ${catalog.cli.frameworkIntroUsage}\n`);
+
+  // Local, no network, no LLM: how often each detected agent was invoked in the local Claude Code history.
+  if (hasAgents) report.agentUsage = collectAgentUsage(report.agents);
+
+  return { gate, hasAgents };
+}
+
+async function resolveAiConsent({ opts, catalog, gate, injectedAsk }) {
+  // CONSENT GATE, MOVED TO BEFORE ANY AI/EGRESS CALL (talents-ai-score, ADR-051 — explicit product decision that AMENDS ADR-010/011/003 on purpose, not a bug fix).
+  const state = loadConsentState();
+  const decision = getConsentDecision(state);
+  const consentSkip = computeConsentSkip({
+    decision,
+    emailVerified: state ? state.emailVerified : undefined,
+    stdinIsTTY: !!process.stdin.isTTY,
+    consentFilePath: consentPath(),
+    catalog,
+  });
+
+  let aiConsentGranted;
+  // A REUSED grant (skip/--json) carries a stale consent email; a fresh prompt re-anchors itself.
+  let reusedStoredConsent = false;
+  if (opts.json) {
+    // `--json` never had an interactive prompt — its whole point is a single parseable stdout document, and it does not gain one now.
+    aiConsentGranted = decision === 'granted' && (!state || state.emailVerified !== false);
+    reusedStoredConsent = true;
+  } else {
+    if (consentSkip.message) {
+      process.stdout.write(`\n  ${consentSkip.message}\n`);
+    }
+    if (consentSkip.skip) {
+      // A TERMINAL decision already exists (a prior run's explicit grant or
+      // denial) — never re-asked, per ADR-007/011.
+      aiConsentGranted = decision === 'granted';
+      reusedStoredConsent = true;
+    } else {
+      const ask = injectedAsk || createStdinAsk();
+      let result;
+      try {
+        result = await runConsentPrompt({
+          ask, catalog, loggedIn: gate.loggedIn, sessionEmail: gate.email, profile: gate.profile,
+        });
+      } finally {
+        if (!injectedAsk) ask.close();
+      }
+      aiConsentGranted = result === 'granted';
+    }
+    if (!aiConsentGranted) {
+      // No early return (reverted 8867450's wall): the local report still renders further down, same as ADR-011 always promised.
+      process.stdout.write(`\n  ${termColors.warning}${catalog.consent.noReportWithoutConsent}${termColors.reset}\n\n`);
+    }
+  }
+  // Re-anchor a reused grant to the session's login-proven email (ADR-006): else a stale consent email ingests the report under another account and this session's AI profile never populates.
+  if (reusedStoredConsent && aiConsentGranted && gate.loggedIn
+    && isValidEmail(gate.email) && state && state.email !== normalizeEmail(gate.email)) {
+    recordConsent('granted', gate.email, { verified: true });
+  }
+  return aiConsentGranted;
+}
+
+function runAggregation({ report, scope, consentEmail, agentRoots, root, catalog }) {
+  withStaticStatus(catalog.cli.aggregatingLabel, () => {
+    report.gitActivity = collectScopedGitActivity(scope.toplevels, consentEmail);
+    // Display-only transparency warning (never feeds scoring, see authorship-mismatch.js).
+    report.authorshipMismatch = detectAuthorshipMismatch(scope.toplevels, consentEmail, report.gitActivity);
+    const sessionSignals = collectSessionSignals(process.env, scope.selectedCwds);
+    report.sessions = sessionSignals.sessions;
+    report.workStreams = collectScopedWorkStreams(scope.toplevels);
+    report.steering = sessionSignals.steering;
+    report.decisions = sessionSignals.decisions;
+    report.detectionEvidence = collectScopedDetectionEvidence(
+      scope.toplevels,
+      consentEmail,
+      report,
+    );
+
+    const scoped = scanForRoots(agentRoots, { root });
+    report.tools = scoped.tools;
+    report.summary = scoped.summary;
+    report.technologies = scoped.technologies;
+    report.mcp = scoped.mcp;
+    report.memory = scoped.memory;
+    report.automations = scoped.automations;
+    report.browserTools = scoped.browserTools;
+    report.agentCounts = scoped.agentCounts;
+    report.environment = scoped.environment;
+
+    report.agents = parseAgentOrgChartForRoots(agentRoots);
+    report.agentCounts.agents = report.agents.length;
+    if (report.agents.length > 0) {
+      report.agentDescriptions = parseAgentDescriptionsForRoots(agentRoots);
+      report.agentDefinitions = parseAgentDefinitionsForRoots(agentRoots);
+      report.agentUsage = collectAgentUsage(report.agents);
+    }
+  });
+}
+
+async function runModelCalls({
+  report, maturity, aiConsentGranted, opts, gate, hasAgents, agentRoots, rootDir, lang, catalog,
+}) {
+  // Which of the three will genuinely be ATTEMPTED.
+  const willAttemptSynthesis = aiConsentGranted && hasAgents && !!getSynthesisEndpoint();
+  const willAttemptEvaluation = aiConsentGranted && hasAgents && !!getAgentEvaluationEndpoint();
+  const roadmapEntryForTier = maturity.tierKey ? getRoadmapEntry(maturity.tierKey, lang) : null;
+  const willAttemptRoadmapPersonalization =
+    aiConsentGranted
+    && gate.showRoadmap
+    && !!roadmapEntryForTier && !roadmapEntryForTier.maxTier
+    && !!getRoadmapEndpoint();
+
+  // THE THREE MODEL CALLS RUN ONE AFTER ANOTHER, NOT IN PARALLEL (issue 116).
+  const runPhase = (willAttempt, label, call) => (willAttempt ? withSpinner(label, call) : call());
+
+  // talents-ai-score, ADR-051: `aiConsentGranted` is `false` whenever consent for this run was declined, denied in the past, or (on `--json`) simply never granted.
+  let synthesis = null;
+  let evaluation = null;
+  let roadmapPersonalization = null;
+  if (aiConsentGranted && !opts.noAi) {
+    synthesis = await runPhase(
+      willAttemptSynthesis,
+      catalog.cli.synthesizingLabel,
+      () => maybeSynthesizeAgents(report, rootDir),
+    );
+    evaluation = hasAgents
+      ? await runPhase(
+        willAttemptEvaluation,
+        catalog.cli.evaluatingAgentsLabel,
+        () => maybeEvaluateAgents(report, agentRoots, lang),
+      )
+      : null;
+    // issue 123 / ADR-044: `runPhase` runs `call()` whether or not a spinner is shown, so gating the roadmap CANNOT be done by flipping `willAttempt` — that only hides the spinner.
+    roadmapPersonalization = gate.showRoadmap
+      ? await runPhase(
+        willAttemptRoadmapPersonalization,
+        catalog.cli.personalizingRoadmapLabel,
+        () => maybePersonalizeRoadmap(report, maturity, lang),
+      )
+      : null;
+  } else {
+    const skipReason = aiConsentGranted ? REASON.NOT_APPLICABLE : REASON.NO_CONSENT;
+    attachModelCall(report, MODEL_CALL.SYNTHESIS, skipped(skipReason));
+    attachModelCall(report, MODEL_CALL.EVALUATION, skipped(skipReason));
+    attachModelCall(report, MODEL_CALL.ROADMAP, skipped(skipReason));
+  }
+
+  if (synthesis) report.agentSynthesis = synthesis;
+  if (evaluation) report.agentEvaluation = evaluation;
+  if (roadmapPersonalization) report.roadmapPersonalization = roadmapPersonalization;
+}
+
+async function renderAndFinalize({ report, maturity, lang, opts, root, gate, catalog, bypassThrottle = false }) {
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ report, maturity }, null, 2) + '\n');
+    return;
+  }
+
+  // Issue 103: revealed by SECTIONS instead of landing in one write.
+  if (gate.sessionStatus === 'expired') {
+    process.stdout.write(`\n  ${termColors.warning}${catalog.terminal.sessionExpiredNotice}${termColors.reset}\n`);
+  }
+
+  await revealText(renderTerminal(report, maturity, lang, { showRoadmap: opts.roadmap, gate }) + '\n', {
+    stream: process.stdout,
+    animate: opts.noAnimation ? false : null,
+  });
+
+  if (opts.save) {
+    try {
+      persistFootprint({ root, report, maturity });
+    } catch {
+      // Never break the local run over a failed state write.
+    }
+  }
+
+  // "Construir el siguiente nivel ahora" (issue 021): optional, only when
+  // explicitly requested — never part of a normal run otherwise.
+  if (opts.buildNextLevel) {
+    doBuildNextLevel(root, maturity, opts.force, catalog);
+  }
+
+  // Auto-send at the end (bypassThrottle only true on the register path).
+  const shareResult = await maybeAutoShare(report, maturity, root, catalog, { bypassThrottle });
+
+  // "My work with AI" preview, best-effort after the send; never blocks/breaks the run.
+  await maybeRenderAiProfile({ report, maturity, lang, root, save: opts.save, submitOk: !!(shareResult && shareResult.ok), catalog });
+}
+
+// A `ready` profile always shows; otherwise the "being evaluated"/setup-only note only shows when this run's submit succeeded.
+function shouldRenderAiProfile({ submitOk, status } = {}) {
+  return status === 'ready' || !!submitOk;
+}
+
+// Previews the hub "My work with AI" profile (matrix + vision E + howIWork F +
+// traction). Shared source with the MCP tool. Setup-only without session/consent.
+async function maybeRenderAiProfile({ report, maturity, lang, root, save, submitOk = true, catalog }, deps = {}) {
+  const {
+    resolve = resolveAiProfilePreview,
+    refreshToken = async () => {
+      const fresh = await ensureFreshSession(process.env);
+      return fresh ? { accessToken: fresh.accessToken, hubAccessToken: fresh.hubAccessToken } : null;
+    },
+    spin = withSpinner,
+    out = process.stdout,
+    loadSession = loadAuthSession,
+    consentDecision = () => getConsentDecision(loadConsentState()),
+  } = deps;
+  try {
+    const session = loadSession();
+    const hasSession = sessionStatus(session) === 'active';
+    const consentGranted = consentDecision() === 'granted';
+    if (!hasSession || !consentGranted) return;
+
+    const result = await spin(
+      catalog.terminal.aiProfileGenerating,
+      () => resolve({ session, endpoint: getAiProfileEndpoint() }, { refreshToken }),
+    );
+    // A failed submit means nothing is in flight — don't tease "being evaluated"/setup-only.
+    if (!shouldRenderAiProfile({ submitOk, status: result && result.status })) return;
+
+    if (result.status === 'ready') {
+      // Re-persist so the HTML report and later state reads show the preview too.
+      report.aiWorkPreview = result.preview;
+      if (save) {
+        try {
+          persistFootprint({ root, report, maturity });
+        } catch {
+          // never break the run over a state re-write
+        }
+      }
+      const block = renderAiProfileTerminal(result, { lang, c: termColors });
+      if (block) out.write(`\n${block}\n`);
+      return;
+    }
+
+    out.write(`\n  ${catalog.terminal.aiProfilePendingRetry}\n`);
+  } catch {
+    // Never break the local run over the (optional) preview.
+  }
+}
+
+module.exports = {
+  performScan,
+  prepareIdentityAndUsage,
+  resolveAiConsent,
+  runAggregation,
+  runModelCalls,
+  renderAndFinalize,
+  shouldRenderAiProfile,
+  maybeRenderAiProfile,
+};

package/src/work-streams.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const { isGitRepo } = require('./git-activity');
+const { takePrefetchedGitLog } = require('./git-log-prefetch');
+
+// Deterministic WORK-STREAM structure for the project where `shakers ai-usage` runs (hybrid evaluation, Slice 2).
+
+const GIT_TIMEOUT_MS = 15000;
+const SESSION_GAP_SECONDS = 4 * 3600;
+const SECONDS_PER_DAY = 86400;
+
+const WORK_STREAMS_LOG_ARGS = ['log', '--no-merges', '--pretty=format:%at'];
+
+function runGitTimestamps(root) {
+  const prefetched = takePrefetchedGitLog(root, WORK_STREAMS_LOG_ARGS);
+  if (prefetched !== undefined) return prefetched;
+  try {
+    return execFileSync(
+      'git',
+      ['-C', root, ...WORK_STREAMS_LOG_ARGS],
+      {
+        encoding: 'utf8',
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: 64 * 1024 * 1024,
+      },
+    );
+  } catch {
+    return null;
+  }
+}
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+function collectWorkStreams(root) {
+  if (!isGitRepo(root)) return null;
+
+  const log = runGitTimestamps(root);
+  if (log === null) return null;
+
+  const timestamps = log
+    .split('\n')
+    .map((line) => Number.parseInt(line.trim(), 10))
+    .filter((n) => Number.isFinite(n))
+    .sort((a, b) => a - b);
+  if (timestamps.length === 0) return null;
+
+  const streams = [];
+  let current = null;
+  for (const ts of timestamps) {
+    if (current && ts - current.last <= SESSION_GAP_SECONDS) {
+      current.last = ts;
+      current.count += 1;
+    } else {
+      current = { first: ts, last: ts, count: 1 };
+      streams.push(current);
+    }
+  }
+
+  const streamCount = streams.length;
+  const spanDaysOf = (s) => Math.floor((s.last - s.first) / SECONDS_PER_DAY);
+  const multiDayStreams = streams.filter((s) => spanDaysOf(s) >= 1).length;
+  const maxStreamSpanDays = streams.reduce(
+    (max, s) => Math.max(max, spanDaysOf(s)),
+    0,
+  );
+
+  return {
+    streamCount,
+    multiDayStreams,
+    avgCommitsPerSession: round2(timestamps.length / streamCount),
+    maxStreamSpanDays,
+  };
+}
+
+module.exports = { collectWorkStreams, SESSION_GAP_SECONDS, WORK_STREAMS_LOG_ARGS };