@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/slash-commands/unified.d.ts

@@ -0,0 +1,38 @@
+/**
+ * UnifiedCommand — a SlashCommand annotated with its source.
+ *
+ * Mirrors opencode's Command.Info.source field so consumers (TUI autocomplete,
+ * /help, /mcp list) can group and label commands uniformly without knowing
+ * where each one came from.
+ *
+ * Today only "builtin" and "mcp" are produced. A future "skill" source is
+ * reserved in the type so we don't need another migration when skills move
+ * into this abstraction.
+ */
+import type { SlashCommand } from "./types.js";
+export type CommandSource = "builtin" | "mcp" | "skill";
+export interface UnifiedCommand extends SlashCommand {
+    source: CommandSource;
+    /**
+     * For source === "mcp" this is the server name. Used by the TUI to render
+     * a ":mcp" badge and by /mcp list to group prompts under their server.
+     */
+    sourceLabel?: string;
+}
+export declare function isUnifiedCommand(cmd: SlashCommand): cmd is UnifiedCommand;
+/**
+ * Wrap a bare SlashCommand into a UnifiedCommand, defaulting to builtin.
+ * Used by the registry so callers that still pass plain SlashCommand objects
+ * (tests, older code paths) keep working.
+ */
+export declare function asUnified(cmd: SlashCommand, source?: CommandSource): UnifiedCommand;
+/**
+ * Stable source ordering used by UIs that group commands (e.g. the slash
+ * autocomplete). Lower rank renders first.
+ *
+ *   builtin → skill → mcp
+ *
+ * Tuned so that "native" commands dominate the palette and user-installed
+ * MCP servers appear after, echoing opencode's autocomplete layout.
+ */
+export declare function sourceRank(source: CommandSource | undefined): number;

package/dist/slash-commands/unified.js

@@ -0,0 +1,38 @@
+/**
+ * UnifiedCommand — a SlashCommand annotated with its source.
+ *
+ * Mirrors opencode's Command.Info.source field so consumers (TUI autocomplete,
+ * /help, /mcp list) can group and label commands uniformly without knowing
+ * where each one came from.
+ *
+ * Today only "builtin" and "mcp" are produced. A future "skill" source is
+ * reserved in the type so we don't need another migration when skills move
+ * into this abstraction.
+ */
+export function isUnifiedCommand(cmd) {
+    return typeof cmd.source === "string";
+}
+/**
+ * Wrap a bare SlashCommand into a UnifiedCommand, defaulting to builtin.
+ * Used by the registry so callers that still pass plain SlashCommand objects
+ * (tests, older code paths) keep working.
+ */
+export function asUnified(cmd, source = "builtin") {
+    return isUnifiedCommand(cmd) ? cmd : { ...cmd, source };
+}
+/**
+ * Stable source ordering used by UIs that group commands (e.g. the slash
+ * autocomplete). Lower rank renders first.
+ *
+ *   builtin → skill → mcp
+ *
+ * Tuned so that "native" commands dominate the palette and user-installed
+ * MCP servers appear after, echoing opencode's autocomplete layout.
+ */
+export function sourceRank(source) {
+    if (!source || source === "builtin")
+        return 0;
+    if (source === "skill")
+        return 1;
+    return 2; // "mcp"
+}

package/dist/stats/usage.d.ts

@@ -0,0 +1,59 @@
+import type { PricingCurrency } from "../model-pricing.js";
+export type StatsRange = "7d" | "30d";
+export interface DailyUsage {
+    date: string;
+    active: boolean;
+    tokens: number;
+    hasPreciseUsage: boolean;
+}
+export interface HeatmapColumn {
+    label: string;
+    cells: Array<DailyUsage | undefined>;
+}
+export interface ModelUsageStats {
+    model: string;
+    displayName: string;
+    providerId?: string;
+    modelId?: string;
+    turns: number;
+    promptTokens: number;
+    completionTokens: number;
+    promptCacheHitTokens: number;
+    promptCacheMissTokens: number;
+    cacheCreationTokens: number;
+    reasoningTokens: number;
+    totalTokens: number;
+    cost?: number;
+    costCurrency?: PricingCurrency;
+}
+export interface UsageStats {
+    range: StatsRange;
+    days: number;
+    startDate: string;
+    endDate: string;
+    daily: DailyUsage[];
+    heatmap: HeatmapColumn[];
+    models: ModelUsageStats[];
+    totalTokens: number;
+    trackedCosts?: Partial<Record<PricingCurrency, number>>;
+    trackedCost?: number;
+    trackedCostCurrency?: PricingCurrency;
+    activeDays: number;
+    sessionsScanned: number;
+    sessionsWithoutTokenData: number;
+}
+export interface UsageStatsBundle {
+    generatedAt: Date;
+    ranges: Record<StatsRange, UsageStats>;
+}
+export declare function collectUsageStatsBundle(options?: {
+    now?: Date;
+    sessionsRoot?: string;
+}): UsageStatsBundle;
+export declare function formatStatsText(bundle: UsageStatsBundle, range?: StatsRange, width?: number): string;
+export declare function formatStatsPanelBody(stats: UsageStats, width?: number, options?: {
+    expandedModels?: boolean;
+}): string;
+export declare function rangeLabel(range: StatsRange): string;
+export declare function formatCompactNumber(value: number): string;
+export declare function formatCurrency(value: number): string;

package/dist/stats/usage.js

@@ -0,0 +1,485 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+import { calculateUsageCost } from "../model-pricing.js";
+import { decodeModel } from "../provider-registry.js";
+const RANGES = [
+    { range: "7d", days: 7 },
+    { range: "30d", days: 30 },
+];
+const WEEKDAY_LABELS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const EMPTY_CELL = " ";
+const HEAT_LEVELS = ["·", "○", "◉", "●"];
+const MAX_MODEL_ROWS = 5;
+export function collectUsageStatsBundle(options = {}) {
+    const now = options.now ?? new Date();
+    const sessionsRoot = options.sessionsRoot ?? join(getBubbleHome(), "sessions");
+    const accumulators = Object.fromEntries(RANGES.map(({ range, days }) => [range, createAccumulator(range, days, now)]));
+    for (const file of listSessionFiles(sessionsRoot)) {
+        processSessionFile(file, accumulators);
+    }
+    return {
+        generatedAt: now,
+        ranges: {
+            "7d": finalizeAccumulator(accumulators["7d"]),
+            "30d": finalizeAccumulator(accumulators["30d"]),
+        },
+    };
+}
+export function formatStatsText(bundle, range = "30d", width = 78) {
+    const stats = bundle.ranges[range];
+    return [
+        `Bubble Stats · ${rangeLabel(range)}`,
+        "",
+        formatStatsPanelBody(stats, width),
+    ].join("\n");
+}
+export function formatStatsPanelBody(stats, width = 72, options = {}) {
+    const bodyWidth = Math.max(48, width);
+    const lines = [];
+    lines.push("Activity");
+    lines.push(...formatHeatmapLines(stats));
+    lines.push("");
+    lines.push("Model usage");
+    lines.push(...formatModelUsageLines(stats, bodyWidth, options.expandedModels ?? false));
+    lines.push("");
+    lines.push("Summary");
+    lines.push(...formatSummaryLines(stats, bodyWidth));
+    return lines.join("\n");
+}
+export function rangeLabel(range) {
+    return range === "7d" ? "Last 7 days" : "Last 30 days";
+}
+export function formatCompactNumber(value) {
+    const abs = Math.abs(value);
+    if (abs >= 1_000_000_000)
+        return `${trimFixed(value / 1_000_000_000, 1)}B`;
+    if (abs >= 1_000_000)
+        return `${trimFixed(value / 1_000_000, 2)}M`;
+    if (abs >= 1_000)
+        return `${trimFixed(value / 1_000, 1)}k`;
+    return String(Math.round(value));
+}
+export function formatCurrency(value) {
+    return formatCurrencyFor(value, "USD");
+}
+function formatCurrencyFor(value, currency) {
+    const amount = value >= 1
+        ? value.toFixed(2)
+        : value >= 0.01
+            ? value.toFixed(3)
+            : value.toFixed(4);
+    return currency === "USD" ? `$${amount}` : `CNY ${amount}`;
+}
+function createAccumulator(range, days, now) {
+    const end = startOfLocalDay(now);
+    const start = addDays(end, -(days - 1));
+    const daily = new Map();
+    for (let i = 0; i < days; i += 1) {
+        const date = localDateKey(addDays(start, i));
+        daily.set(date, {
+            date,
+            active: false,
+            tokens: 0,
+            hasPreciseUsage: false,
+        });
+    }
+    return {
+        range,
+        days,
+        start,
+        end,
+        daily,
+        modelUsage: new Map(),
+        sessionsScanned: 0,
+        sessionsWithoutTokenData: 0,
+    };
+}
+function processSessionFile(file, accumulators) {
+    let entries;
+    try {
+        const content = readFileSync(file, "utf-8");
+        entries = content
+            .split("\n")
+            .filter((line) => line.trim())
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return;
+    }
+    const sessionFlags = Object.fromEntries(RANGES.map(({ range }) => [range, { active: false, hasUsage: false }]));
+    let currentModel;
+    for (const entry of entries) {
+        if (entry.type === "metadata") {
+            currentModel = entry.metadata?.model ?? currentModel;
+            continue;
+        }
+        if (entry.type === "marker" && entry.kind === "model_switch") {
+            currentModel = typeof entry.value === "string" ? entry.value : currentModel;
+        }
+        const timestamp = normalizeTimestamp(entry.timestamp);
+        if (!timestamp)
+            continue;
+        const message = assistantPayload(entry);
+        const model = resolveEntryModel(entry, message, currentModel);
+        const usage = message ? normalizeUsage(message.usage) : undefined;
+        for (const accumulator of Object.values(accumulators)) {
+            if (!isWithinRange(timestamp, accumulator))
+                continue;
+            const flags = sessionFlags[accumulator.range];
+            flags.active = true;
+            markActiveDay(accumulator, timestamp, usage);
+            if (message && usage && model) {
+                flags.hasUsage = true;
+                addModelUsage(accumulator, model, message, usage, timestamp);
+            }
+        }
+    }
+    for (const accumulator of Object.values(accumulators)) {
+        const flags = sessionFlags[accumulator.range];
+        if (!flags.active)
+            continue;
+        accumulator.sessionsScanned += 1;
+        if (!flags.hasUsage)
+            accumulator.sessionsWithoutTokenData += 1;
+    }
+}
+function finalizeAccumulator(accumulator) {
+    const daily = [...accumulator.daily.values()];
+    const models = [...accumulator.modelUsage.values()]
+        .filter((model) => model.totalTokens > 0)
+        .sort((a, b) => b.totalTokens - a.totalTokens);
+    const totalTokens = models.reduce((sum, model) => sum + model.totalTokens, 0);
+    const trackedCosts = aggregateCosts(models);
+    const trackedCostEntries = trackedCosts
+        ? Object.entries(trackedCosts)
+        : [];
+    const trackedCostEntry = trackedCostEntries.length === 1 ? trackedCostEntries[0] : undefined;
+    return {
+        range: accumulator.range,
+        days: accumulator.days,
+        startDate: localDateKey(accumulator.start),
+        endDate: localDateKey(accumulator.end),
+        daily,
+        heatmap: buildHeatmap(daily),
+        models,
+        totalTokens,
+        trackedCosts,
+        trackedCost: trackedCostEntry ? trackedCostEntry[1] : undefined,
+        trackedCostCurrency: trackedCostEntry ? trackedCostEntry[0] : undefined,
+        activeDays: daily.filter((day) => day.active).length,
+        sessionsScanned: accumulator.sessionsScanned,
+        sessionsWithoutTokenData: accumulator.sessionsWithoutTokenData,
+    };
+}
+function addModelUsage(accumulator, model, message, usage, timestamp) {
+    const decoded = decodeModel(model);
+    const providerId = typeof message.providerId === "string" ? message.providerId : decoded.providerId;
+    const modelId = typeof message.modelId === "string" ? message.modelId : decoded.modelId;
+    const key = providerId ? `${providerId}:${modelId}` : model;
+    const existing = accumulator.modelUsage.get(key) ?? {
+        model: key,
+        displayName: key,
+        providerId,
+        modelId,
+        turns: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        promptCacheHitTokens: 0,
+        promptCacheMissTokens: 0,
+        cacheCreationTokens: 0,
+        reasoningTokens: 0,
+        totalTokens: 0,
+    };
+    existing.turns += 1;
+    existing.promptTokens += usage.promptTokens;
+    existing.completionTokens += usage.completionTokens;
+    existing.promptCacheHitTokens += usage.promptCacheHitTokens ?? 0;
+    existing.promptCacheMissTokens += usage.promptCacheMissTokens ?? 0;
+    existing.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
+    existing.reasoningTokens += usage.reasoningTokens ?? 0;
+    existing.totalTokens += tokenTotal(usage);
+    if (providerId && modelId) {
+        const cost = calculateUsageCost(providerId, modelId, usage, timestamp);
+        if (cost) {
+            existing.cost = (existing.cost ?? 0) + cost.cost;
+            existing.costCurrency = cost.currency;
+        }
+    }
+    accumulator.modelUsage.set(key, existing);
+}
+function markActiveDay(accumulator, timestamp, usage) {
+    const key = localDateKey(timestamp);
+    const day = accumulator.daily.get(key);
+    if (!day)
+        return;
+    day.active = true;
+    if (usage) {
+        day.hasPreciseUsage = true;
+        day.tokens += tokenTotal(usage);
+    }
+}
+function buildHeatmap(daily) {
+    const byWeek = new Map();
+    for (const day of daily) {
+        const date = parseLocalDate(day.date);
+        const weekStart = mondayOfWeek(date);
+        const weekKey = localDateKey(weekStart);
+        if (!byWeek.has(weekKey)) {
+            byWeek.set(weekKey, {
+                label: formatMonthDay(weekStart),
+                cells: Array.from({ length: 7 }, () => undefined),
+            });
+        }
+        byWeek.get(weekKey).cells[weekdayIndex(date)] = day;
+    }
+    return [...byWeek.values()];
+}
+function formatHeatmapLines(stats) {
+    if (stats.activeDays === 0)
+        return ["  No activity in this range."];
+    const columns = stats.heatmap;
+    const maxTokens = Math.max(0, ...stats.daily.map((day) => day.tokens));
+    const lines = [
+        `     ${columns.map((column) => column.label.padStart(5, " ")).join(" ")}`,
+    ];
+    for (let row = 0; row < 7; row += 1) {
+        const cells = columns.map((column) => {
+            const day = column.cells[row];
+            return heatmapCell(day, maxTokens).padStart(5, " ");
+        });
+        lines.push(`${WEEKDAY_LABELS[row]}  ${cells.join(" ")}`);
+    }
+    lines.push(`     Less ${HEAT_LEVELS.join(" ")} More`);
+    return lines;
+}
+function formatModelUsageLines(stats, width, expanded) {
+    if (stats.models.length === 0) {
+        return ["  No precise token usage recorded yet."];
+    }
+    const showCost = stats.models.some((model) => model.cost !== undefined);
+    const visibleModels = expanded ? stats.models : stats.models.slice(0, MAX_MODEL_ROWS);
+    const turnsWidth = Math.max(6, ...visibleModels.map((model) => formatTurnCount(model.turns).length));
+    const overhead = (showCost ? 25 : 17) + turnsWidth;
+    const minBarWidth = 4;
+    const longestLabelWidth = Math.max(...visibleModels.map((model) => model.displayName.length));
+    const labelWidth = Math.max(8, Math.min(longestLabelWidth, width - overhead - minBarWidth));
+    const barWidth = Math.max(minBarWidth, Math.min(20, width - labelWidth - overhead));
+    const rows = visibleModels.map((model) => {
+        const percent = stats.totalTokens > 0 ? model.totalTokens / stats.totalTokens : 0;
+        const bar = usageBar(percent, barWidth);
+        const percentText = `${Math.round(percent * 100)}%`.padStart(4, " ");
+        const tokenText = formatCompactNumber(model.totalTokens).padStart(6, " ");
+        const turnsText = formatTurnCount(model.turns).padStart(turnsWidth, " ");
+        const costText = showCost
+            ? ` ${(model.cost !== undefined ? formatCurrencyFor(model.cost, model.costCurrency ?? "USD") : "").padStart(7, " ")}`
+            : "";
+        return `  ${truncate(model.displayName, labelWidth).padEnd(labelWidth, " ")} ${bar} ${percentText} ${tokenText} ${turnsText}${costText}`.trimEnd();
+    });
+    if (stats.models.length > MAX_MODEL_ROWS) {
+        const remaining = stats.models.length - MAX_MODEL_ROWS;
+        rows.push(expanded
+            ? "  ⌃ Show fewer models"
+            : `  › Show ${remaining} more model${remaining === 1 ? "" : "s"}`);
+    }
+    return rows;
+}
+function formatSummaryLines(stats, width) {
+    const favorite = stats.models[0]?.displayName;
+    const lines = [
+        `  Active days ${stats.activeDays}/${stats.days} · Total ${formatCompactNumber(stats.totalTokens)} tokens`,
+    ];
+    if (favorite) {
+        lines.push(`  Favorite model ${truncate(favorite, Math.max(12, width - 17))}`);
+    }
+    const cacheSummary = formatCacheSummary(stats.models);
+    if (cacheSummary)
+        lines.push(`  ${cacheSummary}`);
+    const trackedCostText = formatTrackedCosts(stats);
+    if (trackedCostText)
+        lines.push(`  Tracked cost ${trackedCostText}`);
+    lines.push(`  Sessions scanned ${stats.sessionsScanned}`);
+    if (stats.sessionsWithoutTokenData > 0) {
+        lines.push(`  Sessions without token data ${stats.sessionsWithoutTokenData}`);
+    }
+    return lines;
+}
+function formatCacheSummary(models) {
+    const read = models.reduce((sum, model) => sum + model.promptCacheHitTokens, 0);
+    const create = models.reduce((sum, model) => sum + model.cacheCreationTokens, 0);
+    const missWithCreate = models.reduce((sum, model) => sum + model.promptCacheMissTokens, 0);
+    const miss = Math.max(0, missWithCreate - create);
+    const observed = read + create + miss;
+    if (observed === 0)
+        return undefined;
+    const hitRate = Math.round((read / observed) * 100);
+    return `Prompt cache ${formatCompactNumber(read)} read · ${formatCompactNumber(create)} create · ${formatCompactNumber(miss)} miss · ${hitRate}% hit`;
+}
+function aggregateCosts(models) {
+    const totals = {};
+    for (const model of models) {
+        if (model.cost === undefined)
+            continue;
+        const currency = model.costCurrency ?? "USD";
+        totals[currency] = (totals[currency] ?? 0) + model.cost;
+    }
+    return Object.keys(totals).length > 0 ? totals : undefined;
+}
+function formatTrackedCosts(stats) {
+    if (stats.trackedCosts) {
+        const parts = Object.entries(stats.trackedCosts)
+            .filter(([, value]) => value > 0)
+            .map(([currency, value]) => formatCurrencyFor(value, currency));
+        return parts.length > 0 ? parts.join(" + ") : undefined;
+    }
+    if (stats.trackedCost !== undefined) {
+        return formatCurrencyFor(stats.trackedCost, stats.trackedCostCurrency ?? "USD");
+    }
+    return undefined;
+}
+function heatmapCell(day, maxTokens) {
+    if (!day)
+        return " ";
+    if (!day.active)
+        return EMPTY_CELL;
+    if (!day.hasPreciseUsage || maxTokens <= 0)
+        return HEAT_LEVELS[0];
+    const ratio = day.tokens / maxTokens;
+    if (ratio <= 0.25)
+        return HEAT_LEVELS[0];
+    if (ratio <= 0.5)
+        return HEAT_LEVELS[1];
+    if (ratio <= 0.75)
+        return HEAT_LEVELS[2];
+    return HEAT_LEVELS[3];
+}
+function usageBar(percent, width) {
+    if (width <= 0)
+        return "";
+    let filled = Math.round(percent * width);
+    if (percent > 0 && filled === 0)
+        filled = 1;
+    filled = Math.max(0, Math.min(width, filled));
+    return "█".repeat(filled) + "░".repeat(width - filled);
+}
+function formatTurnCount(turns) {
+    return `${turns} ${turns === 1 ? "turn" : "turns"}`;
+}
+function assistantPayload(entry) {
+    if (entry.type === "assistant_message")
+        return entry.message;
+    if (entry.type === "message" && entry.data?.role === "assistant")
+        return entry.data;
+    return undefined;
+}
+function resolveEntryModel(entry, message, currentModel) {
+    const model = message?.model ?? entry.model ?? currentModel;
+    return typeof model === "string" && model.trim() ? model : undefined;
+}
+function normalizeUsage(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const value = raw;
+    const rawInputTokens = numberValue(value.input_tokens);
+    const cacheReadTokens = numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens);
+    const cacheCreationTokens = numberValue(value.cacheCreationTokens) ?? numberValue(value.cache_creation_input_tokens);
+    const promptTokens = numberValue(value.promptTokens)
+        ?? (rawInputTokens !== undefined
+            ? rawInputTokens + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0)
+            : undefined);
+    const completionTokens = numberValue(value.completionTokens) ?? numberValue(value.output_tokens);
+    if (promptTokens === undefined || completionTokens === undefined)
+        return undefined;
+    return {
+        promptTokens,
+        completionTokens,
+        promptCacheHitTokens: cacheReadTokens,
+        promptCacheMissTokens: numberValue(value.promptCacheMissTokens)
+            ?? numberValue(value.cache_miss_input_tokens)
+            ?? (rawInputTokens !== undefined ? rawInputTokens + (cacheCreationTokens ?? 0) : undefined),
+        cacheCreationTokens,
+        reasoningTokens: numberValue(value.reasoningTokens),
+        totalTokens: numberValue(value.totalTokens) ?? numberValue(value.total_tokens),
+    };
+}
+function tokenTotal(usage) {
+    return usage.totalTokens ?? (usage.promptTokens + usage.completionTokens);
+}
+function listSessionFiles(root) {
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    for (const projectDir of safeReadDir(root)) {
+        const projectPath = join(root, projectDir);
+        try {
+            if (!statSync(projectPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        for (const file of safeReadDir(projectPath)) {
+            if (file.endsWith(".jsonl"))
+                files.push(join(projectPath, file));
+        }
+    }
+    return files;
+}
+function safeReadDir(path) {
+    try {
+        return readdirSync(path);
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeTimestamp(value) {
+    if (typeof value !== "number" && typeof value !== "string")
+        return undefined;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date : undefined;
+}
+function isWithinRange(date, accumulator) {
+    const day = startOfLocalDay(date);
+    return day.getTime() >= accumulator.start.getTime() && day.getTime() <= accumulator.end.getTime();
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function startOfLocalDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function addDays(date, days) {
+    const next = new Date(date);
+    next.setDate(next.getDate() + days);
+    return next;
+}
+function localDateKey(date) {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, "0");
+    const d = String(date.getDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+}
+function parseLocalDate(value) {
+    const [y, m, d] = value.split("-").map(Number);
+    return new Date(y, (m ?? 1) - 1, d ?? 1);
+}
+function formatMonthDay(date) {
+    return `${String(date.getMonth() + 1).padStart(2, "0")}/${String(date.getDate()).padStart(2, "0")}`;
+}
+function mondayOfWeek(date) {
+    return addDays(startOfLocalDay(date), -weekdayIndex(date));
+}
+function weekdayIndex(date) {
+    return (date.getDay() + 6) % 7;
+}
+function trimFixed(value, fractionDigits) {
+    return value.toFixed(fractionDigits).replace(/\.0+$/, "").replace(/(\.\d*[1-9])0+$/, "$1");
+}
+function truncate(value, width) {
+    if (value.length <= width)
+        return value;
+    if (width <= 1)
+        return value.slice(0, width);
+    return `${value.slice(0, width - 1)}…`;
+}

package/dist/stream-json.d.ts

@@ -0,0 +1,13 @@
+/** Persistent headless transport. One Agent + MCP lifecycle, sequential user turns. */
+import type { Readable } from "node:stream";
+import type { AgentEvent } from "./types.js";
+interface StreamSessionOptions {
+    input: Readable;
+    write: (message: Record<string, unknown>) => void;
+    sessionId: string;
+    model: string;
+    run: (prompt: string) => AsyncIterable<AgentEvent>;
+    onEvent?: (event: AgentEvent) => void;
+}
+export declare function runStreamJsonSession(options: StreamSessionOptions): Promise<void>;
+export {};