copilot-metrics 0.1.0

package/src/otel.js

@@ -0,0 +1,126 @@
+'use strict';
+
+function attrsToObject(attrs) {
+  if (!attrs) return {};
+  if (!Array.isArray(attrs)) return attrs;
+  const out = {};
+  for (const attr of attrs) {
+    const value = attr.value;
+    if (value && typeof value === 'object') {
+      out[attr.key] = value.stringValue ?? value.intValue ?? value.doubleValue ?? value.boolValue ?? value.arrayValue;
+    } else {
+      out[attr.key] = value;
+    }
+  }
+  return out;
+}
+
+function pick(attrs, keys) {
+  for (const key of keys) {
+    const value = attrs[key];
+    if (value !== undefined && value !== null && value !== '') return value;
+  }
+  return null;
+}
+
+function number(attrs, keys) {
+  const value = pick(attrs, keys);
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function flattenSpans(payload) {
+  if (!payload || typeof payload !== 'object') return [];
+  if (payload.name || payload.attributes || payload.spanId) return [payload];
+  const spans = [];
+  for (const resourceSpan of payload.resourceSpans || []) {
+    const resourceAttrs = attrsToObject(resourceSpan.resource && resourceSpan.resource.attributes);
+    for (const scopeSpan of resourceSpan.scopeSpans || []) {
+      for (const span of scopeSpan.spans || []) {
+        spans.push({ ...span, resourceAttributes: resourceAttrs });
+      }
+    }
+  }
+  return spans;
+}
+
+function classifySpan(span) {
+  const attrs = attrsToObject(span.attributes);
+  const operation = String(pick(attrs, ['gen_ai.operation.name', 'llm.operation']) || '').toLowerCase();
+  const name = String(span.name || '').toLowerCase();
+  const hasTokens = number(attrs, [
+    'gen_ai.usage.input_tokens',
+    'llm.usage.prompt_tokens',
+    'gen_ai.usage.output_tokens',
+    'llm.usage.completion_tokens',
+  ]) > 0;
+
+  if (operation.includes('agent') || operation.includes('tool') || name.includes('agent') || name.includes('tool')) {
+    return 'non_billable';
+  }
+  if (hasTokens || operation.includes('chat') || operation.includes('completion') || operation.includes('generate')) {
+    return 'llm';
+  }
+  return 'other';
+}
+
+function normalizeSpan(span, source, rawLine) {
+  const attrs = attrsToObject(span.attributes);
+  const resourceAttrs = attrsToObject(span.resourceAttributes);
+  const type = classifySpan(span);
+  if (type !== 'llm') return null;
+
+  return {
+    raw_line: rawLine,
+    span_id: span.spanId || span.span_id || null,
+    trace_id: span.traceId || span.trace_id || null,
+    parent_span_id: span.parentSpanId || span.parent_span_id || null,
+    timestamp: span.startTimeUnixNano || span.start_time || attrs['timestamp'] || null,
+    surface: source,
+    conversation_id: pick(attrs, ['gen_ai.conversation.id', 'conversation.id', 'copilot.conversation.id']),
+    session_id: pick(attrs, ['session.id', 'copilot.session.id']),
+    requested_model: pick(attrs, ['gen_ai.request.model', 'llm.request.model', 'llm.model_name']),
+    resolved_model: pick(attrs, ['gen_ai.response.model', 'llm.response.model', 'model']),
+    repo: pick(attrs, ['vcs.repository.name', 'git.repository', 'repo']) || pick(resourceAttrs, ['vcs.repository.name', 'service.name']),
+    branch: pick(attrs, ['vcs.branch.name', 'git.branch', 'branch']),
+    cwd: pick(attrs, ['process.command_line.cwd', 'cwd', 'working_directory']),
+    commit_sha: pick(attrs, ['vcs.revision', 'git.commit', 'commit']),
+    task_hint: pick(attrs, ['task_hint', 'task.hint', 'copilot.task.hint', 'title']),
+    prompt_preview: pick(attrs, ['prompt_preview', 'prompt.preview']),
+    input_tokens: number(attrs, ['gen_ai.usage.input_tokens', 'llm.usage.prompt_tokens', 'input_tokens', 'prompt_tokens']),
+    output_tokens: number(attrs, ['gen_ai.usage.output_tokens', 'llm.usage.completion_tokens', 'output_tokens', 'completion_tokens']),
+    cache_read_tokens: number(attrs, ['gen_ai.usage.cache_read_input_tokens', 'gen_ai.usage.cached_input_tokens', 'cache_read_tokens']),
+    cache_creation_tokens: number(attrs, ['gen_ai.usage.cache_creation_input_tokens', 'gen_ai.usage.cache_write_input_tokens', 'cache_creation_tokens']),
+    reasoning_tokens: number(attrs, ['gen_ai.usage.reasoning_tokens', 'reasoning_tokens']),
+    warnings: [],
+  };
+}
+
+function normalizePayload(payload, source, rawLine) {
+  return flattenSpans(payload)
+    .map((span) => normalizeSpan(span, source, rawLine))
+    .filter(Boolean);
+}
+
+function normalizeHookEvent(payload, source, rawLine) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+  return {
+    raw_line: rawLine,
+    event: payload.event || null,
+    session_id: payload.session_id || payload.sessionId || null,
+    cwd: payload.cwd || null,
+    repo: payload.repo || payload.repository || null,
+    branch: payload.branch || payload.gitBranch || null,
+    task_hint: payload.task_hint || payload.taskHint || null,
+    labels: Array.isArray(payload.labels) ? payload.labels : [],
+    payload,
+  };
+}
+
+module.exports = {
+  attrsToObject,
+  flattenSpans,
+  classifySpan,
+  normalizePayload,
+  normalizeHookEvent,
+};

package/src/paths.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+
+function defaultDataHome(env = process.env, platform = process.platform) {
+  if (env.COPILOT_METRICS_HOME) return path.resolve(env.COPILOT_METRICS_HOME);
+
+  if (platform === 'win32') {
+    const base = env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(base, 'copilot-metrics');
+  }
+
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'copilot-metrics');
+  }
+
+  const xdg = env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+  return path.join(xdg, 'copilot-metrics');
+}
+
+function resolvePaths(options = {}) {
+  const env = options.env || process.env;
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const home = path.resolve(options.home || defaultDataHome(env, options.platform || process.platform));
+  const telemetryDir = path.join(home, 'telemetry');
+  const hooksDir = path.join(home, 'hooks');
+  const storeDir = path.join(home, 'store');
+  const skillsDir = path.join(home, 'skills');
+  const copilotHome = env.COPILOT_HOME || path.join(os.homedir(), '.copilot');
+
+  return {
+    home,
+    telemetryDir,
+    hooksDir,
+    storeDir,
+    skillsDir,
+    vscodeOtelJsonl: path.join(telemetryDir, 'vscode-copilot-otel.jsonl'),
+    copilotCliOtelJsonl: path.join(telemetryDir, 'copilot-cli-otel.jsonl'),
+    hookEventsJsonl: path.join(hooksDir, 'copilot-hooks.jsonl'),
+    usageDb: path.join(storeDir, 'copilot-metrics.sqlite'),
+    configJson: path.join(home, 'config.json'),
+    localHookConfig: path.join(cwd, '.github', 'hooks', 'copilot-metrics.json'),
+    globalHookConfig: path.join(copilotHome, 'settings.json'),
+  };
+}
+
+module.exports = {
+  defaultDataHome,
+  resolvePaths,
+};

package/src/pricing.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const PRICING_VERSION = 'github-copilot-2026-06-01';
+
+// USD per 1M tokens. Source: GitHub Copilot models and pricing docs, checked 2026-05-30.
+const MODEL_PRICES = {
+  'gpt-4.1': { input: 2.00, cacheRead: 0.50, cacheWrite: 0, output: 8.00 },
+  'gpt-5 mini': { input: 0.25, cacheRead: 0.025, cacheWrite: 0, output: 2.00 },
+  'gpt-5-mini': { input: 0.25, cacheRead: 0.025, cacheWrite: 0, output: 2.00 },
+  'gpt-5.2': { input: 1.75, cacheRead: 0.175, cacheWrite: 0, output: 14.00 },
+  'gpt-5.2-codex': { input: 1.75, cacheRead: 0.175, cacheWrite: 0, output: 14.00 },
+  'gpt-5.3-codex': { input: 1.75, cacheRead: 0.175, cacheWrite: 0, output: 14.00 },
+  'gpt-5.4': { input: 2.50, cacheRead: 0.25, cacheWrite: 0, output: 15.00 },
+  'gpt-5.4 mini': { input: 0.75, cacheRead: 0.075, cacheWrite: 0, output: 4.50 },
+  'gpt-5.4-mini': { input: 0.75, cacheRead: 0.075, cacheWrite: 0, output: 4.50 },
+  'gpt-5.4 nano': { input: 0.20, cacheRead: 0.02, cacheWrite: 0, output: 1.25 },
+  'gpt-5.4-nano': { input: 0.20, cacheRead: 0.02, cacheWrite: 0, output: 1.25 },
+  'gpt-5.5': { input: 5.00, cacheRead: 0.50, cacheWrite: 0, output: 30.00 },
+  'claude haiku 4.5': { input: 1.00, cacheRead: 0.10, cacheWrite: 1.25, output: 5.00 },
+  'claude sonnet 4': { input: 3.00, cacheRead: 0.30, cacheWrite: 3.75, output: 15.00 },
+  'claude sonnet 4.5': { input: 3.00, cacheRead: 0.30, cacheWrite: 3.75, output: 15.00 },
+  'claude sonnet 4.6': { input: 3.00, cacheRead: 0.30, cacheWrite: 3.75, output: 15.00 },
+  'claude opus 4.5': { input: 5.00, cacheRead: 0.50, cacheWrite: 6.25, output: 25.00 },
+  'claude opus 4.6': { input: 5.00, cacheRead: 0.50, cacheWrite: 6.25, output: 25.00 },
+  'claude opus 4.7': { input: 5.00, cacheRead: 0.50, cacheWrite: 6.25, output: 25.00 },
+  'claude opus 4.8': { input: 5.00, cacheRead: 0.50, cacheWrite: 6.25, output: 25.00 },
+  'gemini 2.5 pro': { input: 1.25, cacheRead: 0.125, cacheWrite: 0, output: 10.00 },
+  'gemini 3 flash': { input: 0.50, cacheRead: 0.05, cacheWrite: 0, output: 3.00 },
+  'gemini 3.1 pro': { input: 2.00, cacheRead: 0.20, cacheWrite: 0, output: 12.00 },
+  'gemini 3.5 flash': { input: 1.50, cacheRead: 0.15, cacheWrite: 0, output: 9.00 },
+  'raptor mini': { input: 0.25, cacheRead: 0.025, cacheWrite: 0, output: 2.00 },
+};
+
+function normalizeModelName(model) {
+  return String(model || '').trim().toLowerCase();
+}
+
+function estimateCost(record) {
+  const model = normalizeModelName(record.resolved_model || record.requested_model);
+  const price = MODEL_PRICES[model];
+  if (!model) {
+    return { estimated_usd: null, estimated_ai_credits: null, warning: 'missing_model' };
+  }
+  if (!price) {
+    return { estimated_usd: null, estimated_ai_credits: null, warning: `unknown_model:${model}` };
+  }
+
+  const usd = (
+    (record.input_tokens / 1_000_000) * price.input
+    + (record.output_tokens / 1_000_000) * price.output
+    + (record.cache_read_tokens / 1_000_000) * price.cacheRead
+    + (record.cache_creation_tokens / 1_000_000) * price.cacheWrite
+  );
+
+  return {
+    estimated_usd: Number(usd.toFixed(8)),
+    estimated_ai_credits: Number((usd / 0.01).toFixed(6)),
+    warning: null,
+  };
+}
+
+module.exports = {
+  PRICING_VERSION,
+  MODEL_PRICES,
+  estimateCost,
+};

package/src/reports.js

@@ -0,0 +1,245 @@
+'use strict';
+
+const { queryRows } = require('./sqlite-store');
+const { canonicalLabel } = require('./label-extractors');
+
+function n(value) {
+  return Number(value || 0);
+}
+
+function estimateLabel(rows) {
+  return rows.find((row) => row.estimate_label)?.estimate_label || 'estimate:unknown';
+}
+
+function formatNumber(value) {
+  return n(value).toLocaleString('en-US');
+}
+
+function formatCredits(value) {
+  return n(value).toFixed(6);
+}
+
+function table(headers, rows) {
+  const widths = headers.map((header, index) => Math.max(
+    header.length,
+    ...rows.map((row) => String(row[index] ?? '').length),
+  ));
+  const line = headers.map((header, index) => header.padEnd(widths[index])).join('  ');
+  const sep = widths.map((width) => '-'.repeat(width)).join('  ');
+  const body = rows.map((row) => row.map((cell, index) => String(cell ?? '').padEnd(widths[index])).join('  '));
+  return [line, sep, ...body].join('\n');
+}
+
+async function labelOverview(dbPath) {
+  return queryRows(dbPath, `
+SELECT
+  labels.label,
+  (SELECT COUNT(DISTINCT session_id) FROM label_evidence WHERE label = labels.label) AS sessions,
+  (SELECT COUNT(*) FROM label_evidence WHERE label = labels.label) AS evidence_count,
+  (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) AS usage_records,
+  COALESCE((SELECT SUM(input_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS input_tokens,
+  COALESCE((SELECT SUM(output_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS output_tokens,
+  COALESCE((SELECT SUM(cache_read_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS cache_read_tokens,
+  COALESCE((SELECT SUM(cache_creation_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS cache_creation_tokens,
+  COALESCE((SELECT SUM(reasoning_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS reasoning_tokens,
+  COALESCE((SELECT SUM(COALESCE(estimated_ai_credits, 0)) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS estimated_ai_credits,
+  (SELECT MIN(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS first_seen,
+  (SELECT MAX(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS last_seen,
+  (SELECT MAX(estimate_label) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)) AS estimate_label
+FROM (SELECT DISTINCT label FROM label_evidence) labels
+ORDER BY estimated_ai_credits DESC, labels.label`);
+}
+
+async function labelSummary(dbPath, label) {
+  const rows = await queryRows(dbPath, `
+SELECT
+  labels.label,
+  (SELECT COUNT(DISTINCT session_id) FROM label_evidence WHERE label = labels.label) AS sessions,
+  (SELECT COUNT(*) FROM label_evidence WHERE label = labels.label) AS evidence_count,
+  (SELECT COUNT(DISTINCT usage_record_id) FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL) AS usage_records,
+  COALESCE((SELECT SUM(input_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS input_tokens,
+  COALESCE((SELECT SUM(output_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS output_tokens,
+  COALESCE((SELECT SUM(cache_read_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS cache_read_tokens,
+  COALESCE((SELECT SUM(cache_creation_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS cache_creation_tokens,
+  COALESCE((SELECT SUM(reasoning_tokens) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS reasoning_tokens,
+  COALESCE((SELECT SUM(COALESCE(estimated_ai_credits, 0)) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)), 0) AS estimated_ai_credits,
+  (SELECT MIN(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS first_seen,
+  (SELECT MAX(COALESCE(ur.timestamp, le.timestamp, le.imported_at)) FROM label_evidence le LEFT JOIN usage_records ur ON ur.id = le.usage_record_id WHERE le.label = labels.label) AS last_seen,
+  (SELECT MAX(estimate_label) FROM usage_records WHERE id IN (SELECT DISTINCT usage_record_id FROM label_evidence WHERE label = labels.label AND usage_record_id IS NOT NULL)) AS estimate_label
+FROM (SELECT DISTINCT label FROM label_evidence WHERE label = ?) labels`, [canonicalLabel(label)]);
+  return rows[0] || null;
+}
+
+async function labelDetails(dbPath, label) {
+  return queryRows(dbPath, `
+SELECT
+  le.label,
+  le.source_type,
+  le.source_field,
+  le.source_value,
+  le.confidence,
+  le.session_id,
+  le.repo,
+  le.branch,
+  le.cwd,
+  ur.id AS usage_record_id,
+  ur.surface,
+  ur.resolved_model,
+  ur.input_tokens,
+  ur.output_tokens,
+  ur.estimated_ai_credits,
+  ur.estimate_label,
+  COALESCE(ur.timestamp, le.timestamp, le.imported_at) AS timestamp
+FROM label_evidence le
+LEFT JOIN usage_records ur ON ur.id = le.usage_record_id
+WHERE le.label = ?
+ORDER BY timestamp, le.source_type, le.source_field`, [canonicalLabel(label)]);
+}
+
+async function modelReport(dbPath) {
+  return queryRows(dbPath, `
+SELECT
+  COALESCE(resolved_model, requested_model, 'unknown') AS model,
+  COUNT(*) AS usage_records,
+  SUM(input_tokens) AS input_tokens,
+  SUM(output_tokens) AS output_tokens,
+  SUM(cache_read_tokens) AS cache_read_tokens,
+  SUM(cache_creation_tokens) AS cache_creation_tokens,
+  SUM(reasoning_tokens) AS reasoning_tokens,
+  SUM(COALESCE(estimated_ai_credits, 0)) AS estimated_ai_credits,
+  MAX(estimate_label) AS estimate_label
+FROM usage_records
+GROUP BY COALESCE(resolved_model, requested_model, 'unknown')
+ORDER BY estimated_ai_credits DESC, model`);
+}
+
+async function repoReport(dbPath) {
+  return queryRows(dbPath, `
+SELECT
+  COALESCE(repo, 'unknown') AS repo,
+  COALESCE(cwd, '') AS cwd,
+  COUNT(*) AS usage_records,
+  COUNT(DISTINCT session_id) AS sessions,
+  SUM(input_tokens) AS input_tokens,
+  SUM(output_tokens) AS output_tokens,
+  SUM(COALESCE(estimated_ai_credits, 0)) AS estimated_ai_credits,
+  MAX(estimate_label) AS estimate_label
+FROM usage_records
+GROUP BY COALESCE(repo, 'unknown'), COALESCE(cwd, '')
+ORDER BY estimated_ai_credits DESC, repo, cwd`);
+}
+
+async function unattributedReport(dbPath) {
+  return queryRows(dbPath, `
+SELECT
+  ur.id,
+  ur.source,
+  ur.surface,
+  ur.session_id,
+  ur.conversation_id,
+  ur.repo,
+  ur.branch,
+  ur.cwd,
+  ur.resolved_model,
+  ur.input_tokens,
+  ur.output_tokens,
+  ur.estimated_ai_credits,
+  ur.estimate_label,
+  ur.timestamp
+FROM usage_records ur
+WHERE NOT EXISTS (
+  SELECT 1 FROM label_evidence le WHERE le.usage_record_id = ur.id
+)
+ORDER BY ur.timestamp, ur.id`);
+}
+
+function formatLabels(rows) {
+  return [
+    table(
+      ['Label', 'Sessions', 'Input', 'Output', 'Credits', 'Evidence', 'Last seen'],
+      rows.map((row) => [
+        row.label,
+        row.sessions,
+        formatNumber(row.input_tokens),
+        formatNumber(row.output_tokens),
+        formatCredits(row.estimated_ai_credits),
+        row.evidence_count,
+        row.last_seen || '',
+      ]),
+    ),
+    '',
+    `Costs are estimates (${estimateLabel(rows)}).`,
+  ].join('\n');
+}
+
+function formatLabelSummary(summary, details = null) {
+  if (!summary) return 'No usage found for label.';
+  const lines = [
+    table(
+      ['Label', 'Sessions', 'Input', 'Output', 'Credits', 'Evidence'],
+      [[summary.label, summary.sessions, formatNumber(summary.input_tokens), formatNumber(summary.output_tokens), formatCredits(summary.estimated_ai_credits), summary.evidence_count]],
+    ),
+  ];
+  if (details) {
+    lines.push('', table(
+      ['Source', 'Field', 'Session', 'Model', 'Credits', 'Value'],
+      details.map((row) => [
+        row.source_type,
+        row.source_field,
+        row.session_id || '',
+        row.resolved_model || '',
+        formatCredits(row.estimated_ai_credits),
+        row.source_value || '',
+      ]),
+    ));
+  }
+  lines.push('', `Costs are estimates (${summary.estimate_label || 'estimate:unknown'}).`);
+  return lines.join('\n');
+}
+
+function formatModels(rows) {
+  return [
+    table(
+      ['Model', 'Records', 'Input', 'Output', 'Credits'],
+      rows.map((row) => [row.model, row.usage_records, formatNumber(row.input_tokens), formatNumber(row.output_tokens), formatCredits(row.estimated_ai_credits)]),
+    ),
+    '',
+    `Costs are estimates (${estimateLabel(rows)}).`,
+  ].join('\n');
+}
+
+function formatRepos(rows) {
+  return [
+    table(
+      ['Repo', 'CWD', 'Sessions', 'Input', 'Output', 'Credits'],
+      rows.map((row) => [row.repo, row.cwd, row.sessions, formatNumber(row.input_tokens), formatNumber(row.output_tokens), formatCredits(row.estimated_ai_credits)]),
+    ),
+    '',
+    `Costs are estimates (${estimateLabel(rows)}).`,
+  ].join('\n');
+}
+
+function formatUnattributed(rows) {
+  return [
+    table(
+      ['ID', 'Source', 'Session', 'Repo', 'Branch', 'CWD', 'Model', 'Credits'],
+      rows.map((row) => [row.id, row.source, row.session_id || '', row.repo || '', row.branch || '', row.cwd || '', row.resolved_model || '', formatCredits(row.estimated_ai_credits)]),
+    ),
+    '',
+    `Costs are estimates (${estimateLabel(rows)}).`,
+  ].join('\n');
+}
+
+module.exports = {
+  labelOverview,
+  labelSummary,
+  labelDetails,
+  modelReport,
+  repoReport,
+  unattributedReport,
+  formatLabels,
+  formatLabelSummary,
+  formatModels,
+  formatRepos,
+  formatUnattributed,
+};

package/src/setup.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { resolvePaths } = require('./paths');
+
+const HOOK_SURFACES = ['both', 'copilot-cli', 'vscode'];
+
+const COPILOT_CLI_HOOK_EVENTS = [
+  'sessionStart',
+  'sessionEnd',
+  'userPromptSubmitted',
+  'preToolUse',
+  'postToolUse',
+  'agentStop',
+  'subagentStop',
+  'errorOccurred',
+];
+
+const VSCODE_HOOK_EVENTS = [
+  'SessionStart',
+  'UserPromptSubmit',
+  'PreToolUse',
+  'PostToolUse',
+  'PreCompact',
+  'SubagentStart',
+  'SubagentStop',
+  'Stop',
+];
+
+function writePrivateFile(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file, data, { mode: 0o600 });
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function ensureDataDirs(paths) {
+  for (const dir of [paths.home, paths.telemetryDir, paths.hooksDir, paths.storeDir, paths.skillsDir]) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  if (!fs.existsSync(paths.configJson)) {
+    writePrivateFile(paths.configJson, `${JSON.stringify({
+      version: 1,
+      contentCapture: false,
+      telemetry: {
+        vscode: paths.vscodeOtelJsonl,
+        copilotCli: paths.copilotCliOtelJsonl,
+      },
+      sources: {
+        vscode: {
+          telemetry: paths.vscodeOtelJsonl,
+          hooks: paths.hookEventsJsonl,
+        },
+        copilotCli: {
+          telemetry: paths.copilotCliOtelJsonl,
+          hooks: paths.hookEventsJsonl,
+        },
+      },
+      labelExtractors: [],
+    }, null, 2)}\n`);
+  }
+}
+
+function vscodeSettings(paths) {
+  return {
+    'github.copilot.chat.otel.enabled': true,
+    'github.copilot.chat.otel.exporterType': 'file',
+    'github.copilot.chat.otel.outfile': paths.vscodeOtelJsonl,
+    'github.copilot.chat.otel.captureContent': false,
+  };
+}
+
+function copilotCliEnvironment(paths) {
+  return {
+    COPILOT_OTEL_ENABLED: 'true',
+    COPILOT_OTEL_EXPORTER_TYPE: 'file',
+    COPILOT_OTEL_FILE_EXPORTER_PATH: paths.copilotCliOtelJsonl,
+    OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT: 'false',
+  };
+}
+
+function shellExports(env) {
+  return Object.entries(env)
+    .map(([key, value]) => `export ${key}=${JSON.stringify(value)}`)
+    .join('\n');
+}
+
+function packageBinCommand(cwd) {
+  return path.join(cwd, 'bin', 'copilot-metrics.js');
+}
+
+function hookEventsForSurface(surface) {
+  if (surface === 'copilot-cli' || surface === 'both') return COPILOT_CLI_HOOK_EVENTS;
+  if (surface === 'vscode') return VSCODE_HOOK_EVENTS;
+  throw new Error(`Unknown hook surface "${surface}". Use "both", "copilot-cli", or "vscode".`);
+}
+
+function hookCommand(command, event, metricsHome) {
+  return `COPILOT_METRICS_HOME=${shellQuote(metricsHome)} node ${shellQuote(command)} hook-log --event ${shellQuote(event)} --quiet`;
+}
+
+function hookConfig(paths, options = {}) {
+  const surface = options.surface || 'both';
+  const events = hookEventsForSurface(surface);
+  const command = options.command || packageBinCommand(options.cwd || process.cwd());
+  const commandHook = (event) => ({
+    type: 'command',
+    bash: hookCommand(command, event, paths.home),
+    command: hookCommand(command, event, paths.home),
+    env: {
+      COPILOT_METRICS_HOME: paths.home,
+    },
+    timeout: 10,
+    timeoutSec: 10,
+  });
+  return {
+    version: 1,
+    hooks: Object.fromEntries(events.map((event) => [
+      event,
+      [commandHook(event)],
+    ])),
+  };
+}
+
+function hookTarget(paths, scope) {
+  if (scope === 'global') return paths.globalHookConfig;
+  if (scope === 'local') return paths.localHookConfig;
+  throw new Error(`Unknown hook scope "${scope}". Use "local" or "global".`);
+}
+
+function mergeGlobalSettingsHooks(settings, hooks) {
+  const next = { ...settings };
+  const existingHooks = next.hooks || {};
+  const mergedHooks = {};
+  const isMetricsHook = (hook) => {
+    const command = `${hook.bash || ''}\n${hook.powershell || ''}\n${hook.command || ''}`;
+    return command.includes('copilot-metrics') && command.includes('hook-log');
+  };
+
+  for (const event of new Set([...Object.keys(existingHooks), ...Object.keys(hooks)])) {
+    const existing = Array.isArray(existingHooks[event]) ? existingHooks[event].filter((hook) => !isMetricsHook(hook)) : [];
+    const additions = Array.isArray(hooks[event]) ? hooks[event] : [];
+    if (existing.length > 0 || additions.length > 0) {
+      mergedHooks[event] = [...existing, ...additions];
+    }
+  }
+
+  next.hooks = mergedHooks;
+  return next;
+}
+
+function installHook(paths, options = {}) {
+  const scope = options.scope || 'local';
+  const target = hookTarget(paths, scope);
+  const config = hookConfig(paths, { ...options, scope });
+  if (scope === 'global') {
+    let settings = {};
+    if (fs.existsSync(target)) {
+      settings = JSON.parse(fs.readFileSync(target, 'utf8'));
+    }
+    writePrivateFile(target, `${JSON.stringify(mergeGlobalSettingsHooks(settings, config.hooks), null, 2)}\n`);
+    return { target, config };
+  }
+  writePrivateFile(target, `${JSON.stringify(config, null, 2)}\n`);
+  return { target, config };
+}
+
+function setupSnapshot(options = {}) {
+  const paths = resolvePaths(options);
+  return {
+    paths,
+    vscode: vscodeSettings(paths),
+    copilotCli: copilotCliEnvironment(paths),
+    hooks: hookConfig(paths, options),
+  };
+}
+
+module.exports = {
+  HOOK_SURFACES,
+  COPILOT_CLI_HOOK_EVENTS,
+  VSCODE_HOOK_EVENTS,
+  ensureDataDirs,
+  vscodeSettings,
+  copilotCliEnvironment,
+  shellExports,
+  shellQuote,
+  hookConfig,
+  hookTarget,
+  installHook,
+  mergeGlobalSettingsHooks,
+  setupSnapshot,
+};