Function analyzeMessages

src/diagnostics/token-analyzer.ts:119–227

(
  sessionId: string,
  messages: Message[],
  opts: AnalyzeOptions,
)

/** Run the analysis. Pure function — no I/O. */
export function analyzeMessages(
  sessionId: string,
  messages: Message[],
  opts: AnalyzeOptions,
): TokenReport {
  const turns = groupIntoTurns(messages);
  const breakdowns: TurnBreakdown[] = [];

  // Per-tool aggregation
  const toolStats = new Map<string, { calls: number; tokens: number }>();
  // Per-file aggregation (best-effort: matches tool calls whose args contain a `path`/`file_path`)
  const fileStats = new Map<string, { reads: number; tokens: number }>();

  for (let i = 0; i < turns.length; i++) {
    const turn = turns[i]!;
    let userTok = 0;
    let assistantTok = 0;
    let resultTok = 0;

    for (const m of turn) {
      if (m.role === 'user') {
        userTok += estimateTokens(m.content);
      } else if (m.role === 'assistant') {
        assistantTok += estimateTokens(m.content);
        if (m.tool_calls) {
          assistantTok += estimateTokensJson(m.tool_calls);
          // Track per-tool / per-file usage from the EMITTED calls (results come in `tool` messages)
          for (const tc of m.tool_calls) {
            const toolName = tc.function?.name ?? '(unknown)';
            const entry = toolStats.get(toolName) ?? { calls: 0, tokens: 0 };
            entry.calls += 1;
            toolStats.set(toolName, entry);
            // Extract file path heuristically
            try {
              const args = JSON.parse(tc.function?.arguments ?? '{}');
              const p = (args?.path ?? args?.file_path ?? args?.filename) as string | undefined;
              if (typeof p === 'string' && p.length < 256) {
                const e = fileStats.get(p) ?? { reads: 0, tokens: 0 };
                e.reads += 1;
                fileStats.set(p, e);
              }
            } catch (err) {
              // Unparseable tool-call args mean this call's file/path attribution is
              // skipped — log so the resulting undercount in diagnostics is traceable.
              logger.debug('token-analyzer: failed to parse tool-call arguments', { tool: toolName, err });
            }
          }
        }
      } else if (m.role === 'tool') {
        const tokens = estimateTokens(m.content);
        resultTok += tokens;
        // Attribute these tokens to the tool that produced them (lookup by tool_call_id is complex,
        // but `name` is set on tool messages when the agent records them).
        if ((m as any).name) {
          const t = (m as any).name as string;
          const entry = toolStats.get(t) ?? { calls: 0, tokens: 0 };
          entry.tokens += tokens;
          toolStats.set(t, entry);