@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/serve.d.ts

@@ -0,0 +1,37 @@
+import type { Provider } from './provider';
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    token?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    fetch?: typeof fetch;
+    heartbeatMs?: number;
+    err?: (s: string) => void;
+}
+export interface ServeHandle {
+    port: number;
+    token: string;
+    url: string;
+    close(): Promise<void>;
+}
+export type PermissionMode = 'ask' | 'bypassPermissions';
+/**
+ * One-line terminal banner for `bccli serve`. A token the user supplied (`--token` or
+ * `BCCLI_SERVE_TOKEN`) is left out so it cannot leak into logs; a token BCCLI generated
+ * itself must be printed or nobody could connect.
+ */
+export declare function serveBanner(handle: {
+    url: string;
+    token: string;
+}, opts?: {
+    token?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+/**
+ * Starts the loopback session server (HTTP unary + WS mux at /v1/mux). Refuses
+ * non-loopback bind addresses; every request passes the DSH-style trust fence
+ * (403) and, except /health, the bearer-token check (401).
+ */
+export declare function startServe(opts?: ServeOptions): Promise<ServeHandle>;

package/dist/serveHeartbeat.d.ts

@@ -0,0 +1,14 @@
+export interface Heartbeat {
+    /** Sends the first ping and schedules the check loop. Idempotent until stop(). */
+    start(): void;
+    /** Marks the last ping as answered (ws 'pong' event). */
+    pong(): void;
+    /** Clears the timer; no further pings or terminations. */
+    stop(): void;
+}
+/**
+ * ws heartbeat with deadline: every interval a ping goes out; a ping left
+ * unanswered by the next tick terminates the socket (connection, not stream).
+ * Modeled on the DSH gateway's `websocketHeartbeatIntervalMs` behavior.
+ */
+export declare function createHeartbeat(intervalMs: number, ping: () => void, terminate: () => void): Heartbeat;

package/dist/serveProtocol.d.ts

@@ -0,0 +1,47 @@
+/** Wire frames of the /v1/mux WebSocket (subset of the DSH stream protocol). */
+export type ClientFrame = {
+    type: 'open';
+    streamId: string;
+    target: string;
+} | {
+    type: 'cancel';
+    streamId: string;
+};
+export type ServerFrame = {
+    type: 'item';
+    streamId: string;
+    value: unknown;
+} | {
+    type: 'end';
+    streamId: string;
+} | {
+    type: 'error';
+    streamId: string;
+    message: string;
+};
+/** Uplink frame size limit; oversized frames error their stream without closing the socket. */
+export declare const MAX_FRAME_BYTES = 262144;
+/**
+ * Parses one uplink mux frame. Malformed JSON, unknown types, an empty streamId,
+ * or an `open` without a target produce `{ error }` instead of throwing.
+ */
+export declare function parseClientFrame(raw: string): ClientFrame | {
+    error: string;
+};
+/** Addresses `bccli serve` is allowed to bind (loopback only; 0.0.0.0 is refused). */
+export declare const LOOPBACK_BIND: Set<string>;
+/**
+ * DSH-style trust fence: loopback Host with a port matching the listener, a
+ * same-machine Origin when attached, and no cross-site sec-fetch-site. Returns
+ * null when trusted, else the 403 reason. Never establishes identity — the
+ * bearer token does.
+ */
+export declare function trustFence(headers: {
+    host?: string;
+    origin?: string;
+    'sec-fetch-site'?: string;
+}, port: number): string | null;
+/** Timing-safe `Authorization: Bearer <token>` check. */
+export declare function bearerOk(header: string | undefined, token: string): boolean;
+/** Fresh 32-byte hex serve token. */
+export declare function randomToken(): string;

package/dist/session-GKEXDJKZ.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  Session,
+  pruneSessions
+} from "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
+import "./chunk-BLOYFIAD.js";
+import "./chunk-UZWJQF67.js";
+export {
+  Session,
+  pruneSessions
+};

package/dist/session.d.ts

@@ -0,0 +1,30 @@
+import { type ChatMessage, type Usage } from './provider';
+export declare class Session {
+    readonly file: string;
+    constructor(file: string);
+    static create(home: string, cwd: string, now?: Date): Session;
+    static list(home: string, cwd: string): {
+        session: Session;
+        mtime: Date;
+        preview: string;
+    }[];
+    static latest(home: string, cwd: string): Session | undefined;
+    private write;
+    append(message: ChatMessage): void;
+    appendUsage(usage: Usage & {
+        model?: string;
+    }): void;
+    reset(): void;
+    private records;
+    /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+    load(): ChatMessage[];
+    /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+    lastModel(): string | undefined;
+    /**
+     * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+     * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+     * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+     */
+    loadHistory(): ChatMessage[];
+}
+export declare function pruneSessions(home: string, now?: number, maxAgeDays?: number): number;

package/dist/setup-OV3NWQN5.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  createRuntime,
+  lunaPtcAutoEnabled
+} from "./chunk-PZRKU4UM.js";
+import "./chunk-QZKLZELZ.js";
+import "./chunk-BGXNR74O.js";
+import "./chunk-45SDLMTV.js";
+import "./chunk-PSO7R5AD.js";
+import "./chunk-MHIYLXJC.js";
+import "./chunk-GN4W3T6E.js";
+import "./chunk-75BECX4F.js";
+import "./chunk-JHPGOAXU.js";
+import "./chunk-MFHCQQEN.js";
+import "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
+import "./chunk-BLOYFIAD.js";
+import "./chunk-24JN75FZ.js";
+import "./chunk-FLQPE4S5.js";
+import "./chunk-UZWJQF67.js";
+export {
+  createRuntime,
+  lunaPtcAutoEnabled
+};

package/dist/setup.d.ts

@@ -0,0 +1,74 @@
+import { Agent } from './agent';
+import { CheckpointStore } from './checkpoints';
+import type { McpServerSpec } from './mcp/config';
+import { McpManager } from './mcp/manager';
+import type { CliArgs } from './args';
+import { type Config } from './config';
+import { type AgentDef, type CommandDef, type SkillDef } from './extensions';
+import { type ModelGroup } from './models';
+import { type ChatMessage, type Provider } from './provider';
+import type { ReasoningLevel } from './reasoning';
+import { addProviderKey } from './providerCli';
+import { Session } from './session';
+import { type Interaction } from './tools/plan';
+import { TodoStore } from './tools/todo';
+import { type PluginPayload } from './plugins';
+import type { HookEvent } from './hooks';
+export interface Runtime {
+    cwd: string;
+    home: string;
+    config: Config;
+    modelRef: string;
+    reasoning: ReasoningLevel;
+    agent: Agent;
+    session: Session;
+    setModel(ref: string): void;
+    setReasoning(level: ReasoningLevel): void;
+    env: NodeJS.ProcessEnv;
+    skills: SkillDef[];
+    commands: CommandDef[];
+    agentDefs: AgentDef[];
+    todos: TodoStore;
+    interaction: Interaction;
+    mcp: McpManager;
+    startMcp(specs: McpServerSpec[]): Promise<void>;
+    reloadConfig(): void;
+    providerLabel(): string;
+    listModels: (only?: string) => Promise<ModelGroup[]>;
+    addProviderKey(id: string, key: string): ReturnType<typeof addProviderKey>;
+    /** Continue an earlier session: load its history and append new messages to its file. */
+    resume(session: Session): void;
+    /** Starts a fresh session file; the previous one stays on disk for /resume. */
+    newSession(): void;
+    /** Re-reads AGENTS.md/BCCLI.md into the system prompt (after /memory). */
+    rebuildSystemPrompt(): void;
+    /** Fires a plugin observer event (SessionStart/Stop are emitted here; tool events come from the agent). */
+    emitPlugins(event: HookEvent, payload?: PluginPayload): Promise<void>;
+    checkpoints: CheckpointStore;
+    /**
+     * Steps back n conversation turns: truncates the history (and the session log) to before
+     * them and restores the file snapshots they took. Returns undefined when nothing is left.
+     */
+    rewindTurns(n: number): Promise<RewindResult | undefined>;
+    startedAt: Date;
+}
+export interface RewindResult {
+    turns: number;
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+/** PTC is automatic for Luna. This env var is only an emergency/internal kill switch. */
+export declare function lunaPtcAutoEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function createRuntime(opts: {
+    cwd: string;
+    args: CliArgs;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    history?: ChatMessage[];
+    fetch?: typeof fetch;
+    userHome?: string;
+    /** Override langkah agent (mis. githubBot.stepLimit) — menang atas config.maxSteps. */
+    maxSteps?: number | null;
+}): Runtime;

package/dist/slash/copy.d.ts

@@ -0,0 +1 @@
+export declare function osc52(text: string, inTmux: boolean): string;

package/dist/slash/diff.d.ts

@@ -0,0 +1 @@
+export declare function gitDiff(cwd: string, maxLines?: number, bin?: string): Promise<string>;

package/dist/slash/doctor.d.ts

@@ -0,0 +1,18 @@
+export interface DoctorDeps {
+    which: (cmd: string) => boolean | Promise<boolean>;
+    nodeVersion: string;
+    listModels: () => Promise<unknown[]>;
+}
+export declare function doctorText(input: {
+    providers: {
+        id: string;
+        name: string;
+        ready: boolean;
+    }[];
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+    }[];
+    activeProvider: string;
+}, deps: DoctorDeps): Promise<string>;

package/dist/slash/export.d.ts

@@ -0,0 +1,2 @@
+import { type ChatMessage } from '../provider';
+export declare function exportMarkdown(messages: ChatMessage[], title: string): string;

package/dist/slash/info.d.ts

@@ -0,0 +1,45 @@
+export interface StatusInput {
+    version: string;
+    modelRef: string;
+    providerLabel: string;
+    mode: string;
+    cwd: string;
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+        tools: number;
+    }[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    lastInputTokens: number;
+}
+export declare function statusText(s: StatusInput): string;
+export declare function agentsText(defs: {
+    name: string;
+    description: string;
+    tools?: string[];
+    model?: string;
+}[]): string;
+export declare function skillsText(skills: {
+    name: string;
+    description: string;
+    dir: string;
+}[], commands: {
+    name: string;
+    description?: string;
+}[]): string;
+export declare function sessionText(s: {
+    file: string;
+    started: Date;
+    messages: number;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    modelRef: string;
+}): string;

package/dist/slash/memory.d.ts

@@ -0,0 +1,10 @@
+export declare function instructionFiles(cwd: string, home: string): {
+    path: string;
+    lines: number;
+}[];
+export declare function appendMemory(file: string, text: string): void;
+/** `/memory [global] <teks>` → target file and text; text is empty when nothing follows. */
+export declare function parseMemoryArgs(args: string): {
+    global: boolean;
+    text: string;
+};

package/dist/statsCli-CF3R7ATL.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+import {
+  estimateTokens
+} from "./chunk-QZKLZELZ.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/statsCli.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function isUsageRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.t === "usage" && typeof v.inputTokens === "number" && typeof v.outputTokens === "number";
+}
+function isMsgRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.t === "msg" && !!v.m;
+}
+function emptyRow(project) {
+  return {
+    project,
+    sessions: 0,
+    messages: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    usageInputTokens: 0,
+    usageOutputTokens: 0,
+    cachedInputTokens: 0,
+    cacheWriteTokens: 0,
+    toolCalls: {},
+    sessionTotals: [],
+    modelUsage: {}
+  };
+}
+function aggregateSessions(home, opts) {
+  const now = opts.now ?? Date.now();
+  const cutoff = now - opts.days * 864e5;
+  const root = join(home, "sessions");
+  if (!existsSync(root)) return [];
+  const byProject = /* @__PURE__ */ new Map();
+  for (const project of readdirSync(root)) {
+    const dir = join(root, project);
+    let st;
+    try {
+      st = statSync(dir);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    for (const file of readdirSync(dir)) {
+      if (!file.endsWith(".jsonl")) continue;
+      const path = join(dir, file);
+      let fst;
+      try {
+        fst = statSync(path);
+      } catch {
+        continue;
+      }
+      if (fst.mtimeMs < cutoff) continue;
+      let row = byProject.get(project);
+      if (!row) {
+        row = emptyRow(project);
+        byProject.set(project, row);
+      }
+      row.sessions++;
+      let usageIn = 0;
+      let usageOut = 0;
+      let cachedIn = 0;
+      let cacheWrite = 0;
+      let usageCount = 0;
+      let estIn = 0;
+      let estOut = 0;
+      let messages = 0;
+      const tools = {};
+      for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (isUsageRecord(record)) {
+          usageIn += record.inputTokens;
+          usageOut += record.outputTokens;
+          cachedIn += record.cachedInputTokens ?? 0;
+          cacheWrite += record.cacheWriteTokens ?? 0;
+          usageCount++;
+          if (record.model) {
+            let mt = row.modelUsage[record.model];
+            if (!mt) {
+              mt = { turns: 0, inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0 };
+              row.modelUsage[record.model] = mt;
+            }
+            mt.turns++;
+            mt.inputTokens += record.inputTokens;
+            mt.outputTokens += record.outputTokens;
+            mt.cachedInputTokens += record.cachedInputTokens ?? 0;
+            mt.cacheWriteTokens += record.cacheWriteTokens ?? 0;
+          }
+          continue;
+        }
+        if (!isMsgRecord(record)) continue;
+        messages++;
+        if (record.m.role === "user" || record.m.role === "assistant") {
+          const text = typeof record.m.content === "string" ? record.m.content : JSON.stringify(record.m.content ?? "");
+          const tokens = estimateTokens(text);
+          if (record.m.role === "user") estIn += tokens;
+          else estOut += tokens;
+        }
+        if (record.m.role === "assistant") {
+          for (const call of record.m.tool_calls ?? []) {
+            const name = call?.function?.name;
+            if (typeof name === "string" && name) tools[name] = (tools[name] ?? 0) + 1;
+          }
+        }
+      }
+      row.messages += messages;
+      if (usageCount > 0) {
+        row.usageInputTokens += usageIn;
+        row.usageOutputTokens += usageOut;
+        row.cachedInputTokens += cachedIn;
+        row.cacheWriteTokens += cacheWrite;
+        row.sessionTotals.push(usageIn + usageOut + cachedIn + cacheWrite);
+      } else {
+        row.inputTokens += estIn;
+        row.outputTokens += estOut;
+        row.sessionTotals.push(estIn + estOut);
+      }
+      for (const [name, count] of Object.entries(tools)) row.toolCalls[name] = (row.toolCalls[name] ?? 0) + count;
+    }
+  }
+  return [...byProject.values()].sort((a, b) => b.messages - a.messages || a.project.localeCompare(b.project));
+}
+function fmtCompact(n) {
+  if (n < 1e3) return String(Math.round(n));
+  const units = [
+    [1e9, "B"],
+    [1e6, "M"],
+    [1e3, "K"]
+  ];
+  for (const [size, suffix] of units) {
+    if (n >= size) return `${(n / size).toFixed(1)}${suffix}`;
+  }
+  return String(Math.round(n));
+}
+function fmtCount(n) {
+  return n.toLocaleString("en-US");
+}
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+var BOX_INNER = 46;
+function border(left, right) {
+  return `${left}${"\u2500".repeat(BOX_INNER + 2)}${right}`;
+}
+function center(text) {
+  const pad = Math.max(0, BOX_INNER - text.length);
+  const left = Math.floor(pad / 2);
+  return `\u2502${" ".repeat(left)}${text}${" ".repeat(pad - left)}\u2502`;
+}
+function contentLine(content) {
+  return `\u2502${content}${" ".repeat(Math.max(1, BOX_INNER + 1 - content.length))}\u2502`;
+}
+function valueLine(label, value) {
+  return contentLine(` ${label}${" ".repeat(Math.max(1, BOX_INNER - 1 - label.length - value.length))}${value}`);
+}
+function box(title, rows) {
+  return [border("\u250C", "\u2510"), center(title), border("\u251C", "\u2524"), ...rows.map(([l, v]) => valueLine(l, v)), border("\u2514", "\u2518")];
+}
+function truncateName(name) {
+  return name.length > 18 ? `${name.slice(0, 16)}..` : name;
+}
+function toolBox(tools) {
+  const total = tools.reduce((sum, [, n]) => sum + n, 0);
+  const max = tools[0]?.[1] ?? 1;
+  const lines = tools.map(([name, count]) => {
+    const blocks = Math.max(1, Math.round(count / max * 20));
+    const pct = (count / total * 100).toFixed(1).padStart(5);
+    return contentLine(` ${truncateName(name).padEnd(16)} ${"\u2588".repeat(blocks).padEnd(20)} ${count} (${pct}%)`);
+  });
+  return [border("\u250C", "\u2510"), center("TOOL USAGE"), border("\u251C", "\u2524"), ...lines, border("\u2514", "\u2518")];
+}
+function modelBox(models) {
+  const lines = [];
+  for (let i = 0; i < models.length; i++) {
+    const [name, m] = models[i];
+    if (i > 0) lines.push(border("\u251C", "\u2524"));
+    lines.push(contentLine(` ${truncateName(name)}`));
+    lines.push(valueLine(" Turns", fmtCount(m.turns)));
+    lines.push(valueLine(" Input Tokens", fmtCompact(m.inputTokens)));
+    lines.push(valueLine(" Output Tokens", fmtCompact(m.outputTokens)));
+    lines.push(valueLine(" Cache Read", fmtCompact(m.cachedInputTokens)));
+    lines.push(valueLine(" Cache Write", fmtCompact(m.cacheWriteTokens)));
+  }
+  return [border("\u250C", "\u2510"), center("MODEL USAGE"), border("\u251C", "\u2524"), ...lines, border("\u2514", "\u2518")];
+}
+function projectSlug(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+}
+function runStatsCommand(args, deps) {
+  let days = args.days ?? 7;
+  let toolsCap = args.tools;
+  let modelsFlag = args.models;
+  let projectFilter = args.project;
+  const rest = args.subArgs;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--days" || a === "--tools" || a === "--models" || a === "--project") {
+      const raw = rest[++i] ?? "";
+      if (a === "--days") {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t("--days must be a positive integer"));
+          return 1;
+        }
+        days = n;
+      } else if (a === "--tools") {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t("--tools must be a positive integer"));
+          return 1;
+        }
+        toolsCap = n;
+      } else if (a === "--models") {
+        if (raw === "" || raw === "all" || raw.startsWith("-")) {
+          modelsFlag = "all";
+          if (raw.startsWith("-")) i--;
+        } else {
+          const n = Number(raw);
+          if (!Number.isInteger(n) || n < 1) {
+            deps.err?.(t('--models must be a positive integer or "all"'));
+            return 1;
+          }
+          modelsFlag = raw;
+        }
+      } else {
+        projectFilter = raw;
+      }
+    } else if (a.startsWith("--days=")) {
+      const n = Number(a.slice("--days=".length));
+      if (!Number.isInteger(n) || n < 1) {
+        deps.err?.(t("--days must be a positive integer"));
+        return 1;
+      }
+      days = n;
+    } else if (a.startsWith("--tools=")) {
+      const n = Number(a.slice("--tools=".length));
+      if (!Number.isInteger(n) || n < 1) {
+        deps.err?.(t("--tools must be a positive integer"));
+        return 1;
+      }
+      toolsCap = n;
+    } else if (a.startsWith("--models=")) {
+      const raw = a.slice("--models=".length);
+      if (raw === "" || raw === "all") {
+        modelsFlag = "all";
+      } else {
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 1) {
+          deps.err?.(t('--models must be a positive integer or "all"'));
+          return 1;
+        }
+        modelsFlag = raw;
+      }
+    } else if (a.startsWith("--project=")) {
+      projectFilter = a.slice("--project=".length);
+    }
+  }
+  let rows = aggregateSessions(args.home, { days, now: args.now });
+  if (projectFilter !== void 0) {
+    const needle = projectFilter === "" ? projectSlug(args.cwd ?? "") : projectFilter;
+    rows = rows.filter((r) => r.project.includes(needle));
+  }
+  if (!rows.length) {
+    deps.out(t("no sessions in the last {days} day(s)", { days: String(days) }));
+    return 0;
+  }
+  const sessions = rows.reduce((s, r) => s + r.sessions, 0);
+  const messages = rows.reduce((s, r) => s + r.messages, 0);
+  const input = rows.reduce((s, r) => s + r.inputTokens + r.usageInputTokens, 0);
+  const output = rows.reduce((s, r) => s + r.outputTokens + r.usageOutputTokens, 0);
+  const cachedIn = rows.reduce((s, r) => s + r.cachedInputTokens, 0);
+  const cacheWrite = rows.reduce((s, r) => s + r.cacheWriteTokens, 0);
+  const totals = rows.flatMap((r) => r.sessionTotals);
+  const avg = totals.length ? totals.reduce((s, n) => s + n, 0) / totals.length : 0;
+  const tools = {};
+  for (const r of rows) for (const [name, count] of Object.entries(r.toolCalls)) tools[name] = (tools[name] ?? 0) + count;
+  const modelUsage = {};
+  for (const r of rows) {
+    for (const [name, m] of Object.entries(r.modelUsage)) {
+      let mt = modelUsage[name];
+      if (!mt) {
+        mt = { turns: 0, inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, cacheWriteTokens: 0 };
+        modelUsage[name] = mt;
+      }
+      mt.turns += m.turns;
+      mt.inputTokens += m.inputTokens;
+      mt.outputTokens += m.outputTokens;
+      mt.cachedInputTokens += m.cachedInputTokens;
+      mt.cacheWriteTokens += m.cacheWriteTokens;
+    }
+  }
+  for (const line of box("OVERVIEW", [
+    ["Sessions", fmtCount(sessions)],
+    ["Messages", fmtCount(messages)],
+    ["Days", String(days)]
+  ])) deps.out(line);
+  deps.out("");
+  for (const line of box("TOKENS", [
+    ["Input", fmtCompact(input)],
+    ["Output", fmtCompact(output)],
+    ["Cache Read", fmtCompact(cachedIn)],
+    ["Cache Write", fmtCompact(cacheWrite)],
+    ["Avg Tokens/Session", fmtCompact(avg)],
+    ["Median Tokens/Session", fmtCompact(median(totals))]
+  ])) deps.out(line);
+  if (modelsFlag !== void 0) {
+    let modelEntries = Object.entries(modelUsage).sort(
+      (a, b) => b[1].inputTokens + b[1].outputTokens - (a[1].inputTokens + a[1].outputTokens) || a[0].localeCompare(b[0])
+    );
+    if (modelsFlag !== "all") modelEntries = modelEntries.slice(0, Number(modelsFlag));
+    if (modelEntries.length) {
+      deps.out("");
+      for (const line of modelBox(modelEntries)) deps.out(line);
+    }
+  }
+  let toolEntries = Object.entries(tools).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  if (toolsCap !== void 0) toolEntries = toolEntries.slice(0, toolsCap);
+  if (toolEntries.length) {
+    deps.out("");
+    for (const line of toolBox(toolEntries)) deps.out(line);
+  }
+  deps.out("");
+  deps.out(t("sessions (last {days} day(s)):", { days: String(days) }));
+  for (const r of rows) {
+    const inputTotal = r.inputTokens + r.usageInputTokens;
+    const outputTotal = r.outputTokens + r.usageOutputTokens;
+    deps.out(`${r.project}  ${r.sessions} ${t("session(s)")}  ${r.messages} ${t("message(s)")}  ${fmtCompact(inputTotal)}in/${fmtCompact(outputTotal)}out`);
+  }
+  return 0;
+}
+export {
+  aggregateSessions,
+  fmtCompact,
+  runStatsCommand
+};