@dashclaw/cli 0.7.6 → 0.8.1

package/lib/code/ingest.js

@@ -1,261 +0,0 @@
-// Path B JSONL ingest. Walks `claudeProjectsDir`, posts each .jsonl file to
-// /api/code-sessions/ingest-jsonl with source_host='jsonl'. Per A6 in the
-// goal, the CLI does NOT parse — the server runs the canonical parser.
-//
-// Stream-reads files line-by-line so a large transcript doesn't have to fit
-// in memory all at once. The body always carries raw `jsonl_lines`; when the
-// serialized request exceeds WIRE_COMPRESS_THRESHOLD, postIngest brotli-compresses
-// the whole envelope on the wire (via the `x-dashclaw-encoding: br` header) to fit
-// Vercel's 4.5 MB per-request body limit. Files above MAX_FILE_BYTES are still
-// skipped — compression can't rescue arbitrarily large inputs.
-//
-// Logs per file: { file, posted_lines, status, reason }. NEVER logs raw line
-// content — that would leak the user's transcripts through CI logs.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import readline from 'node:readline';
-import zlib from 'node:zlib';
-import { homedir } from 'node:os';
-
-// Absolute ceiling. Vercel Hobby's 4.5 MB body limit is the binding constraint,
-// applied to the *compressed* wire body. Brotli q9 compresses our JSONL ~4×, so
-// typical-density sessions fit in one request up to ~15-17 MB raw (measured: a
-// 13.3 MB raw session → ~3.5 MB brotli). Density varies, so a file between that
-// and MAX_FILE_BYTES can still exceed the cap and 413; line-chunked POST is the
-// documented future path for those. Files above MAX_FILE_BYTES are skipped
-// outright with `too_large` — no compression rescues them.
-const MAX_FILE_BYTES = 40 * 1024 * 1024;
-// Serialized-JSON byte size above which postIngest brotli-compresses the request
-// body (custom `x-dashclaw-encoding: br` transport). Below this the plain JSON
-// body fits comfortably and we skip the compress CPU cost for the hot path of
-// small per-session deltas. Set well under Vercel's 4.5 MB cap so the *plain*
-// path is only ever used for bodies that are already safe.
-const WIRE_COMPRESS_THRESHOLD = 3 * 1024 * 1024;
-// Brotli quality for the wire body. q9 is the knee of the size/time curve for
-// our payloads (measured on a 14 MB envelope): ~0.8 s at q9 → 3.57 MB, vs q11's
-// ~13 s for only ~0.1 MB less. q10+ cliffs in time for negligible gain; q9
-// still clears Vercel's 4.5 MB cap with ~0.6 MB headroom.
-const BROTLI_QUALITY = 9;
-
-export function defaultClaudeProjectsDir(env = process.env) {
-  if (env.CLAUDE_PROJECTS_DIR) return env.CLAUDE_PROJECTS_DIR;
-  if (process.platform === 'win32') {
-    return path.join(env.USERPROFILE || homedir(), '.claude', 'projects');
-  }
-  return path.join(env.HOME || homedir(), '.claude', 'projects');
-}
-
-function listJsonlFiles(rootDir) {
-  const out = [];
-  let entries;
-  try { entries = fs.readdirSync(rootDir, { withFileTypes: true }); }
-  catch { return out; }
-  for (const e of entries) {
-    const p = path.join(rootDir, e.name);
-    if (e.isDirectory()) {
-      let inner;
-      try { inner = fs.readdirSync(p, { withFileTypes: true }); }
-      catch { continue; }
-      for (const f of inner) {
-        if (f.isFile() && f.name.endsWith('.jsonl')) out.push(path.join(p, f.name));
-      }
-    } else if (e.isFile() && e.name.endsWith('.jsonl')) {
-      out.push(p);
-    }
-  }
-  return out;
-}
-
-async function readLines(filePath) {
-  const lines = [];
-  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const line of rl) {
-    if (line) lines.push(line);
-  }
-  return lines;
-}
-
-// Recover the project's real working directory from the transcript itself.
-// Claude Code stamps a `cwd` field on JSONL records; the encoded directory
-// slug (c--projects-dashclaw) is NOT reversible, so this is the only
-// client-side source of a copy-pasteable path. Bounded scan; null when absent.
-export function deriveCwdFromLines(lines, maxScan = 50) {
-  for (const line of lines.slice(0, maxScan)) {
-    try {
-      const rec = JSON.parse(line);
-      if (rec && typeof rec.cwd === 'string' && rec.cwd.trim()) return rec.cwd;
-    } catch {
-      // Non-JSON line — keep scanning; the parser tolerates these too.
-    }
-  }
-  return null;
-}
-
-export async function buildIngestPayload(filePath, { cwdOverride = null } = {}) {
-  const stat = fs.statSync(filePath);
-  if (stat.size > MAX_FILE_BYTES) {
-    return { tooLarge: true, sizeBytes: stat.size };
-  }
-  const parent = path.dirname(filePath);
-  const slug = path.basename(parent);
-  const lines = await readLines(filePath);
-
-  // Always build the logical body with raw `jsonl_lines`. Wire compression is
-  // decided in postIngest (gzip the whole envelope when it's large) rather than
-  // here — keeping payload construction independent of transport means the same
-  // body serializes identically whether or not it ends up gzipped.
-  const body = {
-    project: {
-      slug,
-      cwd: cwdOverride || deriveCwdFromLines(lines),
-      source_host: 'jsonl',
-    },
-    session_uuid: null,
-    source_file: filePath,
-    source_mtime: stat.mtime.toISOString(),
-    tool_use_action_map: {},
-    jsonl_lines: lines,
-  };
-
-  return {
-    body,
-    sizeBytes: stat.size,
-    lineCount: lines.length,
-  };
-}
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function postIngest(baseUrl, apiKey, body, { fetchImpl = fetch, maxRetries = 4 } = {}) {
-  const url = baseUrl.replace(/\/+$/, '') + '/api/code-sessions/ingest-jsonl';
-  // Decide transport once, outside the retry loop: brotli-compress the JSON
-  // envelope when it's large. The custom `x-dashclaw-encoding: br` header tells
-  // the server to inflate before parsing. Brotli (not gzip) keeps the wire body
-  // under Vercel's 4.5 MB cap for the big sessions that gzip couldn't fit — a
-  // 14 MB envelope is ~4.34 MB gzipped (over the cap) but ~3.5 MB brotli q9.
-  const json = JSON.stringify(body);
-  const jsonBytes = Buffer.byteLength(json, 'utf8');
-  const useCompression = jsonBytes > WIRE_COMPRESS_THRESHOLD;
-  const requestBody = useCompression
-    ? zlib.brotliCompressSync(json, {
-        params: {
-          [zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,
-          [zlib.constants.BROTLI_PARAM_SIZE_HINT]: jsonBytes,
-        },
-      })
-    : json;
-  const headers = { 'content-type': 'application/json', 'x-api-key': apiKey };
-  if (useCompression) headers['x-dashclaw-encoding'] = 'br';
-  let lastStatus = 0;
-  let lastPayload = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const res = await fetchImpl(url, {
-      method: 'POST',
-      headers,
-      body: requestBody,
-    });
-    let payload = null;
-    try { payload = await res.json(); } catch { /* keep payload null */ }
-    if (res.ok) return { status: res.status, ok: true, payload };
-    lastStatus = res.status;
-    lastPayload = payload;
-    // Retry on 429 (rate limit) and 5xx with exponential backoff +
-    // honour Retry-After when the server provides it. Anything else is
-    // surfaced immediately.
-    const retryable = res.status === 429 || (res.status >= 500 && res.status < 600);
-    if (!retryable || attempt === maxRetries) break;
-    const retryAfter = Number(res.headers?.get?.('retry-after')) || 0;
-    const backoffMs = retryAfter > 0
-      ? Math.min(retryAfter * 1000, 30000)
-      : Math.min(1000 * 2 ** attempt, 16000);
-    await sleep(backoffMs);
-  }
-  return { status: lastStatus, ok: false, payload: lastPayload };
-}
-
-/**
- * Run the ingest pipeline. Returns a per-file result array. Throws on
- * total config failure; per-file failures are recorded in the result.
- *
- * @param {Object} args
- * @param {string} args.baseUrl
- * @param {string} args.apiKey
- * @param {string} args.projectsDir
- * @param {boolean} [args.dryRun]   When true, builds payloads but skips POST.
- * @param {Function} [args.fetchImpl]
- * @param {Object}   [args.logger]  { info(line), warn(line) }
- */
-export async function runIngest({
-  baseUrl,
-  apiKey,
-  projectsDir,
-  dryRun = false,
-  fetchImpl = fetch,
-  logger = console,
-}) {
-  if (!baseUrl) throw new Error('runIngest: baseUrl is required');
-  if (!apiKey && !dryRun) throw new Error('runIngest: apiKey is required for live ingest');
-
-  const files = listJsonlFiles(projectsDir);
-  if (!files.length) {
-    logger.info(`No .jsonl files found under ${projectsDir}.`);
-    return [];
-  }
-
-  const results = [];
-  for (const file of files) {
-    let payload;
-    try {
-      payload = await buildIngestPayload(file);
-    } catch (err) {
-      results.push({ file, status: 'error', reason: 'read_failed:' + err.message });
-      logger.warn(`  ${file} -> read_failed: ${err.message}`);
-      continue;
-    }
-    if (payload.tooLarge) {
-      results.push({ file, status: 'skipped', reason: 'too_large', size_bytes: payload.sizeBytes });
-      logger.warn(`  ${file} -> skipped (${payload.sizeBytes} bytes > ${MAX_FILE_BYTES})`);
-      continue;
-    }
-    if (dryRun) {
-      results.push({
-        file,
-        status: 'dry_run',
-        reason: 'no_post',
-        posted_lines: payload.lineCount,
-        size_bytes: payload.sizeBytes,
-        slug: payload.body.project.slug,
-      });
-      logger.info(`  ${file} -> dry_run (${payload.lineCount} lines, slug=${payload.body.project.slug})`);
-      continue;
-    }
-    // Light throttle between live POSTs so a fresh-disk backfill of
-    // hundreds of files doesn't hammer Vercel's per-IP rate limit.
-    if (results.length > 0) await sleep(150);
-    try {
-      const { status, ok, payload: respBody } = await postIngest(baseUrl, apiKey, payload.body, { fetchImpl });
-      if (!ok) {
-        results.push({ file, status: 'error', reason: 'http_' + status, posted_lines: payload.lineCount });
-        logger.warn(`  ${file} -> HTTP ${status}`);
-        continue;
-      }
-      const sess = respBody?.session || {};
-      results.push({
-        file,
-        status: sess.skipped ? 'skipped_unchanged' : 'ingested',
-        reason: sess.reason || 'ok',
-        posted_lines: payload.lineCount,
-        session_id: sess.id || null,
-      });
-      logger.info(`  ${file} -> ${sess.skipped ? 'skipped_unchanged' : 'ingested'} (${payload.lineCount} lines)`);
-    } catch (err) {
-      results.push({ file, status: 'error', reason: 'network:' + err.message });
-      logger.warn(`  ${file} -> network: ${err.message}`);
-    }
-  }
-  return results;
-}

package/lib/code/memo.js

@@ -1,57 +0,0 @@
-// Fetch the most recent weekly memo for a project.
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-async function getMemos(baseUrl, apiKey, projectIdOrSlug, { fetchImpl = fetch }) {
-  const url = baseUrl.replace(/\/+$/, '') + '/api/code-sessions/memos?project=' + encodeURIComponent(projectIdOrSlug);
-  const res = await fetchImpl(url, {
-    headers: { 'x-api-key': apiKey },
-  });
-  let body = null;
-  try { body = await res.json(); } catch { /* keep null */ }
-  return { status: res.status, ok: res.ok, body };
-}
-
-/**
- * @param {Object} args
- * @param {string} args.baseUrl
- * @param {string} args.apiKey
- * @param {string} args.project    Project slug or id.
- * @param {boolean} [args.save]    When true, writes the memo to ./memos/<weekTag>-<slug>.md.
- * @param {Function} [args.fetchImpl]
- * @param {Object}   [args.logger]
- */
-export async function runMemo({ baseUrl, apiKey, project, save = false, fetchImpl = fetch, logger = console }) {
-  if (!baseUrl) throw new Error('runMemo: baseUrl is required');
-  if (!apiKey) throw new Error('runMemo: apiKey is required');
-  if (!project) throw new Error('runMemo: project (slug or id) is required');
-
-  const { status, ok, body } = await getMemos(baseUrl, apiKey, project, { fetchImpl });
-  if (!ok) {
-    throw new Error('HTTP ' + status + (body?.error ? ' — ' + body.error : ''));
-  }
-  const memos = Array.isArray(body?.memos) ? body.memos : [];
-  if (!memos.length) {
-    logger.info('No memos yet for project ' + project + '.');
-    return { saved: false, memo: null };
-  }
-  // Most recent first (the API already sorts by iso_week_tag DESC, but be
-  // defensive in case that contract slips).
-  memos.sort((a, b) => String(b.iso_week_tag).localeCompare(String(a.iso_week_tag)));
-  const memo = memos[0];
-
-  logger.info('--- ' + memo.iso_week_tag + ' ' + project + ' ---');
-  if (memo.body_md) logger.info(memo.body_md);
-
-  if (save) {
-    const dir = path.join(process.cwd(), 'memos');
-    fs.mkdirSync(dir, { recursive: true });
-    const safeSlug = String(project).replace(/[^A-Za-z0-9_.-]+/g, '_').slice(0, 80);
-    const filePath = path.join(dir, memo.iso_week_tag + '-' + safeSlug + '.md');
-    fs.writeFileSync(filePath, memo.body_md || '', 'utf8');
-    logger.info('Saved to ' + filePath);
-    return { saved: true, memo, filePath };
-  }
-  return { saved: false, memo };
-}

package/lib/code/vendored.js

@@ -1,219 +0,0 @@
-// VENDORED from app/lib/claude-code/optimal-files/merge.js and
-// app/lib/claude-code/optimal-files/bundle.js.
-//
-// The CLI is a sibling package and can't import from app/lib/ without
-// monorepo tooling, but Phase 6's `dashclaw code apply` needs the
-// path-traversal guard and the markdown merge applier locally. Keep this
-// file in sync with the canonical source via
-// `node scripts/sync-cli-vendored-code.mjs`.
-//
-// Source of truth:
-//   app/lib/claude-code/optimal-files/merge.js
-//   app/lib/claude-code/optimal-files/bundle.js#absolutize
-//
-// Only `applyMerge`, `previewMerge`, the heading/bullet helpers, and the
-// `_ensureInsideProject` guard are vendored. Everything else stays on the
-// server side.
-
-import path from 'node:path';
-
-// --- _ensureInsideProject (originally from bundle.js#absolutize) ---------
-
-export function _ensureInsideProject(projectCwd, candidatePath) {
-  if (!projectCwd || !candidatePath) return null;
-  let abs;
-  if (path.isAbsolute(candidatePath)) {
-    abs = path.normalize(candidatePath);
-  } else {
-    abs = path.normalize(path.join(projectCwd, candidatePath));
-  }
-  const cwdNorm = path.normalize(projectCwd);
-  const ci = process.platform === 'win32';
-  const a = ci ? abs.toLowerCase() : abs;
-  const b = ci ? cwdNorm.toLowerCase() : cwdNorm;
-  if (a !== b && !a.startsWith(b + path.sep)) return null;
-  return abs;
-}
-
-// --- markdown merge (originally from merge.js) ---------------------------
-
-export function parseMarkdownSections(text) {
-  const lines = String(text || '').split(/\r?\n/);
-  const sections = [];
-  let cur = { level: 0, heading: '__preamble__', headingRaw: '', body: [] };
-  for (const line of lines) {
-    const m = line.match(/^(#{1,6})\s+(.+?)\s*$/);
-    if (m) {
-      sections.push(cur);
-      cur = { level: m[1].length, heading: normalizeHeading(m[2]), headingRaw: m[2], body: [] };
-    } else {
-      cur.body.push(line);
-    }
-  }
-  sections.push(cur);
-  return sections;
-}
-
-export function normalizeHeading(h) {
-  return String(h || '')
-    .toLowerCase()
-    .replace(/[`*_]/g, '')
-    .replace(/[^\w\s]+/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function parseBullets(bodyLines) {
-  const bullets = [];
-  const other = [];
-  for (const line of bodyLines) {
-    if (/^\s*[-*]\s+/.test(line)) bullets.push({ raw: line, normalized: normalizeBullet(line) });
-    else other.push(line);
-  }
-  return { bullets, other };
-}
-
-function normalizeBullet(line) {
-  return String(line || '')
-    .replace(/^\s*[-*]\s+/, '')
-    .replace(/`[^`]*`/g, ' ')
-    .replace(/[^a-z0-9\s]+/gi, ' ')
-    .toLowerCase()
-    .trim()
-    .split(/\s+/)
-    .slice(0, 8)
-    .join(' ');
-}
-
-function bulletAlreadyPresent(generatedNorm, existingBullets) {
-  if (!generatedNorm) return true;
-  for (const b of existingBullets) {
-    if (!b.normalized) continue;
-    if (b.normalized.startsWith(generatedNorm)) return true;
-    if (generatedNorm.startsWith(b.normalized) && b.normalized.length >= 4) return true;
-    const aWords = generatedNorm.split(' ');
-    const bWords = b.normalized.split(' ');
-    let shared = 0;
-    for (let i = 0; i < Math.min(aWords.length, bWords.length); i++) {
-      if (aWords[i] === bWords[i]) shared++; else break;
-    }
-    if (shared >= 5) return true;
-  }
-  return false;
-}
-
-function isFooterSection(section) {
-  if (!section || !Array.isArray(section.body)) return false;
-  const joined = section.body.join('\n').toLowerCase();
-  return (joined.includes('generated by dashclaw') || joined.includes('generated by agentlens')) && joined.includes('review before committing');
-}
-
-function renderSection(section) {
-  return `## ${section.headingRaw}\n${section.body.join('\n')}`.replace(/\n+$/, '\n');
-}
-
-export function previewMerge(existing, generated) {
-  const ex = parseMarkdownSections(existing);
-  const gn = parseMarkdownSections(generated);
-  const exByHeading = new Map();
-  for (const s of ex) {
-    if (s.heading === '__preamble__') continue;
-    if (!exByHeading.has(s.heading)) exByHeading.set(s.heading, s);
-  }
-  const appendSections = [];
-  const sharedSections = [];
-  for (let i = 0; i < gn.length; i++) {
-    const s = gn[i];
-    if (s.heading === '__preamble__') continue;
-    if (isFooterSection(s)) continue;
-    if (s.level !== 2) continue;
-    const exSection = exByHeading.get(s.heading);
-    if (!exSection) {
-      appendSections.push({ heading: s.heading, headingRaw: s.headingRaw, bodyText: renderSection(s) });
-    } else {
-      const exBullets = parseBullets(exSection.body).bullets;
-      const genBullets = parseBullets(s.body).bullets;
-      const candidates = [];
-      for (const gb of genBullets) {
-        if (gb.normalized && !bulletAlreadyPresent(gb.normalized, exBullets)) {
-          candidates.push({ text: gb.raw.replace(/^\s*[-*]\s+/, '- ') });
-        }
-      }
-      if (candidates.length) {
-        sharedSections.push({
-          heading: s.heading,
-          headingRaw: s.headingRaw,
-          existingBulletCount: exBullets.length,
-          candidateBullets: candidates,
-        });
-      }
-    }
-  }
-  return {
-    appendSections,
-    sharedSections,
-    newSectionCount: appendSections.length,
-    sharedSectionCount: sharedSections.length,
-    candidateBulletCount: sharedSections.reduce((acc, s) => acc + s.candidateBullets.length, 0),
-  };
-}
-
-function trimTrailingBlanks(lines) {
-  const out = lines.slice();
-  while (out.length && out[out.length - 1].trim() === '') out.pop();
-  return out;
-}
-
-export function applyMerge(existing, generated, selection) {
-  const preview = previewMerge(existing, generated);
-  selection = selection || {};
-  const acceptedHeadings = new Set((selection.acceptedHeadings || []).map(h => normalizeHeading(h)));
-  const acceptedBulletsByHeading = new Map();
-  for (const b of (selection.acceptedBullets || [])) {
-    const k = normalizeHeading(b.heading);
-    if (!acceptedBulletsByHeading.has(k)) acceptedBulletsByHeading.set(k, []);
-    acceptedBulletsByHeading.get(k).push(b.text);
-  }
-  let merged = String(existing == null ? '' : existing);
-  if (merged && !merged.endsWith('\n')) merged += '\n';
-  if (acceptedBulletsByHeading.size) {
-    const sections = parseMarkdownSections(merged);
-    const rebuilt = [];
-    for (const s of sections) {
-      if (s.heading === '__preamble__') { rebuilt.push(s.body.join('\n')); continue; }
-      const headingLine = `${'#'.repeat(s.level)} ${s.headingRaw}`;
-      const accepted = acceptedBulletsByHeading.get(s.heading) || [];
-      if (accepted.length) {
-        const trimmedBody = trimTrailingBlanks(s.body);
-        rebuilt.push(headingLine);
-        rebuilt.push(trimmedBody.join('\n'));
-        rebuilt.push('');
-        rebuilt.push('<!-- dashclaw:merged-bullets -->');
-        for (const t of accepted) rebuilt.push(t.startsWith('- ') ? t : `- ${t}`);
-        rebuilt.push('<!-- /dashclaw:merged-bullets -->');
-        rebuilt.push('');
-      } else {
-        rebuilt.push(headingLine);
-        rebuilt.push(s.body.join('\n'));
-      }
-    }
-    merged = rebuilt.join('\n').replace(/\n+$/, '\n');
-  }
-  const wholeAdditions = preview.appendSections.filter(s => acceptedHeadings.has(s.heading));
-  if (wholeAdditions.length) {
-    if (!merged.endsWith('\n')) merged += '\n';
-    merged += '\n<!-- dashclaw:merged-sections -->\n\n';
-    for (const s of wholeAdditions) {
-      merged += s.bodyText.endsWith('\n') ? s.bodyText : s.bodyText + '\n';
-      merged += '\n';
-    }
-    merged += '<!-- /dashclaw:merged-sections -->\n';
-  }
-  return {
-    merged,
-    additions: {
-      sections: wholeAdditions.map(s => s.headingRaw),
-      bulletCount: [...acceptedBulletsByHeading.values()].reduce((acc, l) => acc + l.length, 0),
-    },
-  };
-}

package/lib/cost.js

@@ -1,108 +0,0 @@
-// cli/lib/cost.js
-//
-// `dashclaw cost [--lens fleet|claude-code] [--period 7d|30d|90d]` — terminal
-// readback over GET /api/finops/spend (the finops rollups). Defaults:
-// lens=claude-code, period=7d — the wedge user's own Claude Code spend.
-
-import { apiRequest } from './api.js';
-
-export const VALID_LENSES = ['fleet', 'claude-code'];
-export const VALID_PERIODS = ['7d', '30d', '90d'];
-export const USAGE =
-  'Usage: dashclaw cost [--lens fleet|claude-code] [--period 7d|30d|90d]\n' +
-  '  Defaults: --lens claude-code --period 7d';
-
-/** Validate flag values. Returns null when fine, or a usage-bearing message. */
-export function validateCostFlags({ lens, period }) {
-  if (!VALID_LENSES.includes(lens)) {
-    return `Invalid --lens "${lens}". Valid: ${VALID_LENSES.join(', ')}.\n${USAGE}`;
-  }
-  if (!VALID_PERIODS.includes(period)) {
-    return `Invalid --period "${period}". Valid: ${VALID_PERIODS.join(', ')}.\n${USAGE}`;
-  }
-  return null;
-}
-
-export async function fetchSpend(config, { lens, period }) {
-  return apiRequest(config, 'GET', '/api/finops/spend', { query: { lens, period } });
-}
-
-const money = (n) => '$' + Number(n || 0).toFixed(2);
-
-function table(rows) {
-  // rows: [label, value][] — right-pad labels so values align.
-  const width = Math.max(...rows.map(([label]) => label.length));
-  return rows.map(([label, value]) => `  ${label.padEnd(width + 2)}${value}`).join('\n');
-}
-
-function formatClaudeCode(data, period) {
-  const cs = data.code_sessions || {};
-  const total = Number(data.code_total_usd || 0);
-  const sessions = Number(cs.session_count || 0);
-  if (total === 0 && sessions === 0) {
-    return (
-      `No Claude Code spend recorded yet for ${period}.\n` +
-      'Sessions are captured by the Stop hook (on by default, metadata-only;\n' +
-      'opt-out: DASHCLAW_CODE_SESSIONS_ENABLED=0). Run a Claude Code session and check back.'
-    );
-  }
-  const lines = [
-    `Claude Code spend — last ${period}`,
-    '',
-    table([
-      ['Total', money(total)],
-      ['Sessions', String(sessions)],
-      ['Cache saved', money(cs.total_cache_savings_usd)],
-    ]),
-  ];
-  const projects = Array.isArray(cs.by_project) ? cs.by_project.filter((p) => Number(p.cost_usd || 0) > 0) : [];
-  if (projects.length > 0) {
-    lines.push('', '  By project:');
-    lines.push(table(projects.map((p) => [`  ${p.project_name || p.project_id || 'unknown'}`, money(p.cost_usd)])));
-  }
-  lines.push('', `Summary: ${money(total)} across ${sessions} session(s) in the last ${period}.`);
-  return lines.join('\n');
-}
-
-function formatFleet(data, period) {
-  const agent = Number(data.agent?.total_cost_usd || 0);
-  const x402 = Number(data.x402?.total_spend_usd || 0);
-  const total = Number(data.fleet_total_usd || 0);
-  if (total === 0) {
-    return (
-      `No fleet spend recorded yet for ${period}.\n` +
-      'Agent spend lands when governed actions report tokens_in/tokens_out + model.'
-    );
-  }
-  const lines = [
-    `Fleet spend — last ${period}`,
-    '',
-    table([
-      ['Agent LLM', money(agent)],
-      ['x402 purchases', money(x402)],
-      ['Total', money(total)],
-    ]),
-    '',
-    `Summary: ${money(total)} fleet spend in the last ${period} (LLM ${money(agent)} + x402 ${money(x402)}).`,
-  ];
-  return lines.join('\n');
-}
-
-export function formatSpend(data, { lens, period }) {
-  return lens === 'claude-code' ? formatClaudeCode(data, period) : formatFleet(data, period);
-}
-
-/**
- * Validate, fetch, format. Throws a usage-tagged Error on bad flags so the
- * caller prints usage and exits non-zero without a stack trace.
- */
-export async function runCost(config, { lens = 'claude-code', period = '7d' } = {}, { fetcher = fetchSpend } = {}) {
-  const invalid = validateCostFlags({ lens, period });
-  if (invalid) {
-    const err = new Error(invalid);
-    err.usage = true;
-    throw err;
-  }
-  const data = await fetcher(config, { lens, period });
-  return formatSpend(data, { lens, period });
-}