@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/context/usage.js

@@ -0,0 +1,230 @@
+import { getModelContextWindow } from "../model-catalog.js";
+import { SKILL_CATALOG_HEADING, SKILL_CATALOG_INTRO } from "../skills/format.js";
+import { buildDeferredToolsReminder } from "../prompt/reminders.js";
+import { AUTOCOMPACT_BUFFER_TOKENS, estimateMessageTokens, estimateTextTokens, MIN_WINDOW_FOR_RESERVE, OUTPUT_RESERVE_TOKENS, } from "./budget.js";
+export function buildContextUsageSnapshot(input) {
+    const systemMessages = input.messages.filter((message) => message.role === "system");
+    const otherMessages = input.messages.filter((message) => message.role !== "system");
+    const deferredToolEntries = input.deferredToolEntries ?? [];
+    const systemContent = systemMessages.map((message) => message.content).join("\n\n");
+    // The catalog is whatever Skills section the prompt actually carries, whatever its budget.
+    const skillsPrompt = extractSkillCatalog(systemContent);
+    const skillsInSystemPrompt = !!skillsPrompt;
+    const advertisedSkills = skillsPrompt
+        ? skillsPrompt.split("\n").filter((line) => line.startsWith("- ") && !line.startsWith("- … ")).length
+        : 0;
+    const skillsTokens = skillsInSystemPrompt ? estimateTextTokens(skillsPrompt, input.providerId) : 0;
+    const systemPromptTokens = Math.max(0, estimateTextTokens(systemContent, input.providerId) - skillsTokens);
+    const toolsTokens = estimateToolEntriesTokens(input.toolEntries, input.providerId);
+    const deferredToolsTokens = estimateDeferredToolsReminderTokens(deferredToolEntries, input.providerId);
+    const rawOtherTokens = otherMessages.reduce((sum, message) => sum + estimateMessageTokens(message, input.providerId), 0);
+    const otherTokens = Math.max(0, rawOtherTokens - deferredToolsTokens);
+    const usedTokens = systemPromptTokens + toolsTokens + skillsTokens + deferredToolsTokens + otherTokens;
+    const contextWindow = getModelContextWindow(input.providerId, input.modelId);
+    return {
+        providerId: input.providerId,
+        modelId: input.modelId,
+        contextWindow,
+        usedTokens,
+        freeTokens: contextWindow === undefined ? undefined : Math.max(0, contextWindow - usedTokens),
+        buckets: {
+            systemPrompt: {
+                label: "System prompt",
+                tokens: systemPromptTokens,
+                detail: systemMessages.length > 0 ? `${systemMessages.length} system message${systemMessages.length === 1 ? "" : "s"}` : "none",
+            },
+            tools: {
+                label: "Tools",
+                tokens: toolsTokens,
+                detail: input.toolEntries.length > 0 ? `${input.toolEntries.length} active schema${input.toolEntries.length === 1 ? "" : "s"}` : "none",
+            },
+            skills: {
+                label: "Skills",
+                tokens: skillsTokens,
+                detail: advertisedSkills > 0 ? `${advertisedSkills} advertised skill${advertisedSkills === 1 ? "" : "s"}` : "none in current prompt",
+            },
+            deferredTools: {
+                label: "Deferred/MCP",
+                tokens: deferredToolsTokens,
+                detail: deferredToolEntries.length > 0
+                    ? `${deferredToolEntries.length} deferred tool name${deferredToolEntries.length === 1 ? "" : "s"} in reminder`
+                    : "none",
+            },
+            other: {
+                label: "Other",
+                tokens: otherTokens,
+                detail: otherMessages.length > 0 ? `${otherMessages.length} conversation/meta/tool message${otherMessages.length === 1 ? "" : "s"}` : "none",
+            },
+        },
+        toolCount: input.toolEntries.length,
+        deferredToolCount: deferredToolEntries.length,
+        skillCount: advertisedSkills,
+        messageCount: input.messages.length,
+    };
+}
+export function formatContextUsage(snapshot) {
+    const freeTokens = snapshot.freeTokens ?? 0;
+    const rows = [
+        { key: "system", marker: "█", color: ANSI_ORANGE, bucket: snapshot.buckets.systemPrompt },
+        { key: "tools", marker: "▓", color: ANSI_TEAL, bucket: snapshot.buckets.tools },
+        { key: "skills", marker: "▒", color: ANSI_PURPLE, bucket: snapshot.buckets.skills },
+        { key: "deferred", marker: "◆", color: ANSI_BLUE, bucket: snapshot.buckets.deferredTools },
+        { key: "other", marker: "▪", color: ANSI_GRAY, bucket: snapshot.buckets.other },
+    ];
+    const freeRow = {
+        key: "free",
+        marker: "░",
+        color: ANSI_DARK_GRAY,
+        bucket: {
+            label: "Free space",
+            tokens: freeTokens,
+            detail: snapshot.freeTokens === undefined ? "unknown window" : "available before context limit",
+        },
+    };
+    const barRows = snapshot.contextWindow === undefined ? rows : [...rows, freeRow];
+    const barTotal = snapshot.contextWindow ?? Math.max(1, snapshot.usedTokens);
+    const compactAt = snapshot.contextWindow === undefined
+        ? "unknown"
+        : formatTokens(compactionThreshold(snapshot.contextWindow));
+    const lines = [
+        colorize("• Context Usage", ANSI_BOLD),
+        `${colorize(snapshot.providerId || "unknown", ANSI_TEAL)}:${snapshot.modelId || "unknown"} · ${formatUsedWindow(snapshot)} · compaction at ${compactAt}`,
+        `Free space: ${snapshot.freeTokens === undefined ? "unknown" : colorize(`${formatTokens(snapshot.freeTokens)} (${formatPercent(snapshot.freeTokens, snapshot.contextWindow)})`, ANSI_DARK_GRAY)}`,
+        "",
+        buildSegmentedBar(barRows, barTotal),
+        "",
+        colorize("Estimated usage by category", ANSI_BOLD),
+        ...rows.map((row) => formatBucket(row.marker, row.bucket, snapshot.contextWindow)),
+        formatBucket(freeRow.marker, freeRow.bucket, snapshot.contextWindow),
+        "",
+        "Note: estimates include resident messages and active tool schemas; provider tokenization and hidden overhead can differ.",
+    ];
+    return lines.join("\n");
+}
+function estimateToolEntriesTokens(entries, providerId) {
+    return entries.reduce((sum, entry) => {
+        const payload = JSON.stringify({
+            name: entry.name,
+            description: entry.description,
+            parameters: entry.parameters,
+        });
+        return sum + estimateTextTokens(payload, providerId) + 8;
+    }, 0);
+}
+function estimateDeferredToolsReminderTokens(entries, providerId) {
+    if (entries.length === 0)
+        return 0;
+    return estimateTextTokens(buildDeferredToolsReminder(entries.map((entry) => entry.name)), providerId);
+}
+function buildSegmentedBar(rows, totalTokens) {
+    const width = 54;
+    if (rows.every((row) => row.bucket.tokens <= 0)) {
+        return "░".repeat(width);
+    }
+    const safeTotal = Math.max(1, totalTokens);
+    const rawSegments = rows.map((row) => {
+        const exact = (Math.max(0, row.bucket.tokens) / safeTotal) * width;
+        const minWidth = row.marker !== "░" && row.bucket.tokens > 0 ? 1 : 0;
+        return { ...row, exact, width: minWidth };
+    });
+    let assigned = rawSegments.reduce((sum, segment) => sum + segment.width, 0);
+    while (assigned < width && rawSegments.length > 0) {
+        const segment = rawSegments.reduce((best, item) => {
+            const itemDeficit = item.exact - item.width;
+            const bestDeficit = best.exact - best.width;
+            return itemDeficit > bestDeficit ? item : best;
+        }, rawSegments[0]);
+        segment.width += 1;
+        assigned += 1;
+    }
+    while (assigned > width) {
+        const segment = rawSegments
+            .filter((item) => item.width > 0)
+            .sort((a, b) => b.width - a.width)[0];
+        if (!segment)
+            break;
+        segment.width -= 1;
+        assigned -= 1;
+    }
+    return rawSegments.map((segment) => colorize(segment.marker.repeat(segment.width), segment.color)).join("");
+}
+function formatBucket(marker, bucket, contextWindow) {
+    const label = bucket.label.padEnd(13, " ");
+    const count = contextWindow === undefined && bucket.label === "Free space"
+        ? "unknown".padStart(14, " ")
+        : formatTokens(bucket.tokens).padStart(14, " ");
+    const percent = contextWindow === undefined ? "" : ` ${formatPercent(bucket.tokens, contextWindow).padStart(7, " ")}`;
+    const color = colorForLabel(bucket.label);
+    return `${colorize(marker, color)} ${colorize(label, color)} ${count}${percent}  ${bucket.detail ?? "unknown"}`;
+}
+function formatPercent(tokens, contextWindow) {
+    if (!contextWindow || contextWindow <= 0)
+        return "";
+    const percent = (tokens / contextWindow) * 100;
+    if (percent > 0 && percent < 0.1)
+        return "<0.1%";
+    return `${percent.toFixed(1)}%`;
+}
+function formatUsedWindow(snapshot) {
+    if (snapshot.contextWindow === undefined)
+        return `~${formatTokens(snapshot.usedTokens)} used`;
+    return `${formatTokenNumber(snapshot.usedTokens)}/${formatTokenNumber(snapshot.contextWindow)} tokens (${formatPercent(snapshot.usedTokens, snapshot.contextWindow)})`;
+}
+function compactionThreshold(contextWindow) {
+    if (contextWindow >= MIN_WINDOW_FOR_RESERVE) {
+        return Math.max(0, contextWindow - OUTPUT_RESERVE_TOKENS - AUTOCOMPACT_BUFFER_TOKENS);
+    }
+    return Math.floor(contextWindow * 0.75);
+}
+function formatTokens(count) {
+    return `${formatTokenNumber(count)} tokens`;
+}
+function formatTokenNumber(count) {
+    if (count < 1000)
+        return `${Math.round(count)}`;
+    if (count < 1_000_000)
+        return `${formatFixed(count / 1000)}K`;
+    return `${formatFixed(count / 1_000_000)}M`;
+}
+function formatFixed(value) {
+    return value >= 10 ? value.toFixed(0) : value.toFixed(1);
+}
+const ANSI_RESET = "\u001b[0m";
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_ORANGE = "\u001b[38;5;208m";
+const ANSI_TEAL = "\u001b[38;5;73m";
+const ANSI_PURPLE = "\u001b[38;5;141m";
+const ANSI_BLUE = "\u001b[38;5;75m";
+const ANSI_GRAY = "\u001b[38;5;245m";
+const ANSI_DARK_GRAY = "\u001b[38;5;240m";
+function colorize(text, color) {
+    if (!text)
+        return text;
+    return `${color}${text}${ANSI_RESET}`;
+}
+function colorForLabel(label) {
+    if (label === "System prompt")
+        return ANSI_ORANGE;
+    if (label === "Tools")
+        return ANSI_TEAL;
+    if (label === "Skills")
+        return ANSI_PURPLE;
+    if (label === "Deferred/MCP")
+        return ANSI_BLUE;
+    if (label === "Free space")
+        return ANSI_DARK_GRAY;
+    return ANSI_GRAY;
+}
+/**
+ * The Skills catalog the prompt carries: heading plus its fixed intro line, so a
+ * "## Skills" heading in AGENTS.md or memory is never mistaken for it. The last
+ * match wins (the catalog is appended after memory); it ends at the next blank line.
+ */
+function extractSkillCatalog(systemContent) {
+    const marker = `${SKILL_CATALOG_HEADING}\n${SKILL_CATALOG_INTRO}\n`;
+    const at = systemContent.lastIndexOf(marker);
+    if (at < 0 || (at > 0 && !systemContent.slice(0, at).endsWith("\n\n")))
+        return "";
+    const end = systemContent.indexOf("\n\n", at);
+    return systemContent.slice(at, end < 0 ? undefined : end);
+}

package/dist/debug-trace.d.ts

@@ -0,0 +1,27 @@
+import type { AgentEvent, Message, ToolResult } from "./types.js";
+export interface DebugTraceContext {
+    cwd?: string;
+    sessionFile?: string;
+    provider?: string;
+    model?: string;
+    renderer?: string;
+    surface?: string;
+}
+export interface DebugTraceInfo {
+    enabled: boolean;
+    path?: string;
+    runId?: string;
+    rawEnabled: boolean;
+}
+export declare function isDebugTraceEnabled(): boolean;
+export declare function isDebugTraceRawEnabled(): boolean;
+export declare function configureDebugTrace(context: DebugTraceContext): DebugTraceInfo;
+export declare function getDebugTraceInfo(): DebugTraceInfo;
+export declare function traceEvent(phase: string, detail?: Record<string, unknown>, context?: DebugTraceContext): void;
+export declare function summarizeTraceText(value: unknown): Record<string, unknown> | undefined;
+export declare function summarizeTraceValue(value: unknown): Record<string, unknown> | undefined;
+export declare function summarizeTraceMessage(message: Message): Record<string, unknown>;
+export declare function summarizeTraceToolResult(result: ToolResult): Record<string, unknown>;
+export declare function summarizeTraceError(error: unknown): Record<string, unknown>;
+export declare function summarizeAgentEventForTrace(event: AgentEvent): Record<string, unknown>;
+export declare function resetDebugTraceForTests(): void;

package/dist/debug-trace.js

@@ -0,0 +1,401 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { getBubbleHome } from "./bubble-home.js";
+const TRACE_VERSION = 1;
+const TRUE_VALUES = new Set(["1", "true", "yes", "on"]);
+const FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+const DEFAULT_MAX_AGE_DAYS = 7;
+const DEFAULT_RAW_MAX_BYTES = 256 * 1024;
+let initialized = false;
+let tracePath;
+let runId;
+let sequence = 0;
+let startedAt = performance.now();
+let baseContext = {};
+let defaultPruneDone = false;
+export function isDebugTraceEnabled() {
+    const value = process.env.BUBBLE_TRACE?.trim();
+    if (!value)
+        return false;
+    return !FALSE_VALUES.has(value.toLowerCase());
+}
+export function isDebugTraceRawEnabled() {
+    const value = process.env.BUBBLE_TRACE_RAW?.trim().toLowerCase();
+    return !!value && !FALSE_VALUES.has(value);
+}
+export function configureDebugTrace(context) {
+    baseContext = { ...baseContext, ...dropUndefined(context) };
+    const path = ensureTracePath();
+    if (!path)
+        return { enabled: false, rawEnabled: isDebugTraceRawEnabled() };
+    return {
+        enabled: true,
+        path,
+        runId,
+        rawEnabled: isDebugTraceRawEnabled(),
+    };
+}
+export function getDebugTraceInfo() {
+    const path = ensureTracePath();
+    if (!path)
+        return { enabled: false, rawEnabled: isDebugTraceRawEnabled() };
+    return {
+        enabled: true,
+        path,
+        runId,
+        rawEnabled: isDebugTraceRawEnabled(),
+    };
+}
+export function traceEvent(phase, detail, context) {
+    const path = ensureTracePath();
+    if (!path)
+        return;
+    const eventContext = {
+        ...baseContext,
+        ...dropUndefined(context ?? {}),
+    };
+    const line = {
+        traceVersion: TRACE_VERSION,
+        ts: new Date().toISOString(),
+        elapsedMs: Math.round(performance.now() - startedAt),
+        seq: ++sequence,
+        runId,
+        pid: process.pid,
+        phase,
+        ...eventContext,
+        ...(detail ? { detail: sanitizeTraceValue(detail) } : {}),
+    };
+    try {
+        appendFileSync(path, JSON.stringify(line) + "\n", "utf-8");
+    }
+    catch {
+        // Debug tracing must never affect normal agent execution.
+    }
+}
+export function summarizeTraceText(value) {
+    if (typeof value !== "string")
+        return summarizeTraceValue(value);
+    return summarizeString(value);
+}
+export function summarizeTraceValue(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return { type: "null" };
+    if (typeof value === "string")
+        return summarizeString(value);
+    if (typeof value === "number" || typeof value === "boolean") {
+        return { type: typeof value, value };
+    }
+    if (Array.isArray(value)) {
+        return {
+            type: "array",
+            count: value.length,
+            json: summarizeJson(value),
+        };
+    }
+    if (typeof value === "object") {
+        return {
+            type: "object",
+            keys: Object.keys(value).slice(0, 32),
+            json: summarizeJson(value),
+        };
+    }
+    return { type: typeof value, value: String(value) };
+}
+export function summarizeTraceMessage(message) {
+    if (message.role === "assistant") {
+        return {
+            role: message.role,
+            content: summarizeTraceText(message.content),
+            reasoning: summarizeTraceText(message.reasoning ?? ""),
+            error: message.error,
+            providerMetadata: summarizeAssistantProviderMetadata(message),
+            toolCalls: message.toolCalls?.map((call) => ({
+                id: call.id,
+                name: call.name,
+                args: summarizeTraceText(call.arguments),
+                argsCorrupt: call.argsCorrupt,
+            })),
+        };
+    }
+    if (message.role === "tool") {
+        return {
+            role: message.role,
+            toolCallId: message.toolCallId,
+            content: summarizeTraceText(message.content),
+            isError: message.isError,
+            metadata: message.metadata,
+        };
+    }
+    if (message.role === "user") {
+        return {
+            role: message.role,
+            content: summarizeTraceValue(message.content),
+        };
+    }
+    return {
+        role: message.role,
+        kind: "kind" in message ? message.kind : undefined,
+        content: summarizeTraceText(message.content),
+    };
+}
+function summarizeAssistantProviderMetadata(message) {
+    const blocks = message.providerMetadata?.anthropic?.contentBlocks;
+    if (!blocks || blocks.length === 0)
+        return undefined;
+    return {
+        anthropic: {
+            contentBlocks: blocks.length,
+            thinkingBlocks: blocks.filter((block) => block.type === "thinking" || block.type === "redacted_thinking").length,
+            signatureChars: blocks.reduce((sum, block) => sum + (typeof block.signature === "string" ? block.signature.length : 0), 0),
+            types: blocks.map((block) => block.type).slice(0, 32),
+        },
+    };
+}
+export function summarizeTraceToolResult(result) {
+    return {
+        content: summarizeTraceText(result.content),
+        isError: result.isError,
+        status: result.status,
+        metadata: result.metadata,
+    };
+}
+export function summarizeTraceError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: truncateString(error.stack ?? "", 4000),
+        };
+    }
+    return {
+        name: "Error",
+        message: String(error),
+    };
+}
+export function summarizeAgentEventForTrace(event) {
+    switch (event.type) {
+        case "text_delta":
+        case "reasoning_delta":
+            return { type: event.type, content: summarizeTraceText(event.content) };
+        case "hook_start":
+        case "hook_end":
+        case "hook_error":
+            return { ...event };
+        case "tool_call_start":
+            return { type: event.type, id: event.id, name: event.name };
+        case "tool_call_delta":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                argumentsDelta: summarizeTraceText(event.argumentsDelta),
+                arguments: summarizeTraceText(event.arguments),
+            };
+        case "tool_call_end":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                arguments: summarizeTraceText(event.arguments),
+            };
+        case "tool_start":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                args: summarizeTraceValue(event.args),
+            };
+        case "tool_update":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                update: summarizeTraceValue(event.update),
+            };
+        case "tool_end":
+            return {
+                type: event.type,
+                id: event.id,
+                name: event.name,
+                result: summarizeTraceToolResult(event.result),
+            };
+        case "turn_end":
+            return {
+                type: event.type,
+                usage: event.usage,
+                willContinue: event.willContinue,
+            };
+        case "input_applied":
+        case "input_rejected":
+            return {
+                ...event,
+                content: summarizeTraceText(event.content),
+            };
+        default:
+            return { ...event };
+    }
+}
+export function resetDebugTraceForTests() {
+    initialized = false;
+    tracePath = undefined;
+    runId = undefined;
+    sequence = 0;
+    startedAt = performance.now();
+    baseContext = {};
+    defaultPruneDone = false;
+}
+function ensureTracePath() {
+    if (!isDebugTraceEnabled())
+        return undefined;
+    if (initialized)
+        return tracePath;
+    initialized = true;
+    startedAt = performance.now();
+    runId = resolveRunId();
+    tracePath = resolveTracePath(runId);
+    try {
+        mkdirSync(dirname(tracePath), { recursive: true });
+        pruneDefaultTraceDirs();
+    }
+    catch {
+        // The write path may still fail later; tracing remains best-effort.
+    }
+    return tracePath;
+}
+function resolveRunId() {
+    const explicit = process.env.BUBBLE_TRACE_RUN_ID?.trim();
+    if (explicit)
+        return sanitizeFileSegment(explicit);
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `trace-${stamp}-${process.pid}-${randomUUID().slice(0, 8)}`;
+}
+function resolveTracePath(id) {
+    const explicitPath = process.env.BUBBLE_TRACE_PATH?.trim();
+    if (explicitPath)
+        return isAbsolute(explicitPath) ? explicitPath : join(process.cwd(), explicitPath);
+    const value = process.env.BUBBLE_TRACE?.trim();
+    if (value && !TRUE_VALUES.has(value.toLowerCase()) && !FALSE_VALUES.has(value.toLowerCase())) {
+        return isAbsolute(value) ? value : join(process.cwd(), value);
+    }
+    const dateKey = new Date().toISOString().slice(0, 10);
+    return join(getBubbleHome(), "debug-runs", dateKey, `${id}.jsonl`);
+}
+function pruneDefaultTraceDirs() {
+    if (defaultPruneDone || process.env.BUBBLE_TRACE_PATH?.trim())
+        return;
+    defaultPruneDone = true;
+    const maxAgeDays = Number(process.env.BUBBLE_TRACE_MAX_AGE_DAYS ?? DEFAULT_MAX_AGE_DAYS);
+    if (!Number.isFinite(maxAgeDays) || maxAgeDays <= 0)
+        return;
+    const root = join(getBubbleHome(), "debug-runs");
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(root, entry);
+        try {
+            const stat = statSync(path);
+            if (stat.mtimeMs < cutoff)
+                rmSync(path, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup failures.
+        }
+    }
+}
+function summarizeString(value) {
+    const byteLength = Buffer.byteLength(value, "utf8");
+    const summary = {
+        type: "string",
+        chars: value.length,
+        bytes: byteLength,
+        hash: hashString(value),
+    };
+    if (isDebugTraceRawEnabled()) {
+        summary.raw = truncateRaw(value, byteLength);
+    }
+    return summary;
+}
+function summarizeJson(value) {
+    const json = safeJsonStringify(value);
+    if (json === undefined)
+        return { serializable: false };
+    const byteLength = Buffer.byteLength(json, "utf8");
+    const summary = {
+        serializable: true,
+        chars: json.length,
+        bytes: byteLength,
+        hash: hashString(json),
+    };
+    if (isDebugTraceRawEnabled()) {
+        summary.raw = truncateRaw(json, byteLength);
+    }
+    return summary;
+}
+function sanitizeTraceValue(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeTraceValue(item));
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (item !== undefined)
+                out[key] = sanitizeTraceValue(item);
+        }
+        return out;
+    }
+    return String(value);
+}
+function truncateRaw(value, byteLength) {
+    const limit = Number(process.env.BUBBLE_TRACE_RAW_MAX_BYTES ?? DEFAULT_RAW_MAX_BYTES);
+    if (!Number.isFinite(limit) || limit <= 0 || byteLength <= limit)
+        return value;
+    return {
+        value: value.slice(0, Math.max(0, limit)),
+        truncated: true,
+        bytes: byteLength,
+    };
+}
+function truncateString(value, maxChars) {
+    if (!value)
+        return undefined;
+    return value.length > maxChars ? `${value.slice(0, maxChars)}...` : value;
+}
+function hashString(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function dropUndefined(value) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item !== undefined)
+            out[key] = item;
+    }
+    return out;
+}
+function sanitizeFileSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "trace";
+}

package/dist/diff-stats.d.ts

@@ -0,0 +1,5 @@
+export interface DiffChangeStats {
+    added: number;
+    removed: number;
+}
+export declare function countUnifiedDiffChanges(diff: string): DiffChangeStats;

package/dist/diff-stats.js

@@ -0,0 +1,21 @@
+export function countUnifiedDiffChanges(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.replace(/\r\n/g, "\n").split("\n")) {
+        if (isUnifiedDiffMetadataLine(line))
+            continue;
+        if (line.startsWith("+"))
+            added++;
+        else if (line.startsWith("-"))
+            removed++;
+    }
+    return { added, removed };
+}
+function isUnifiedDiffMetadataLine(line) {
+    return (line.startsWith("+++") ||
+        line.startsWith("---") ||
+        line.startsWith("@@") ||
+        line.startsWith("Index:") ||
+        line.startsWith("===") ||
+        line.startsWith("\\ No newline"));
+}