wave-code 1.0.10 → 1.1.1

package/dist/utils/markdownTable.js

@@ -1,302 +0,0 @@
-import stringWidth from "string-width";
-import wrapAnsi from "wrap-ansi";
-import { stripAnsiColors } from "wave-agent-sdk";
-/**
- * Accounts for parent indentation (e.g. message prefix) and terminal
- * resize races. Without enough margin the table overflows its layout box
- * and Ink's clip truncates differently on alternating frames.
- */
-const SAFETY_MARGIN = 4;
-/** Minimum column width to prevent degenerate layouts */
-const MIN_COLUMN_WIDTH = 3;
-/**
- * Maximum number of lines per row before switching to vertical format.
- * When wrapping would make rows taller than this, vertical (key-value)
- * format provides better readability.
- */
-const MAX_ROW_LINES = 4;
-/** ANSI escape codes for text formatting */
-const ANSI_BOLD_START = "\x1b[1m";
-const ANSI_BOLD_END = "\x1b[22m";
-/**
- * Wrap text to fit within a given width, returning array of lines.
- * ANSI-aware: preserves styling across line breaks.
- *
- * @param hard - If true, break words that exceed width (needed when columns
- *               are narrower than the longest word). Default false.
- */
-export function wrapText(text, width, options) {
-    if (width <= 0)
-        return [text];
-    // Strip trailing whitespace/newlines before wrapping, otherwise extra
-    // blank lines would appear in table cells.
-    const trimmedText = text.trimEnd();
-    const wrapped = wrapAnsi(trimmedText, width, {
-        hard: options?.hard ?? false,
-        trim: false,
-        wordWrap: true,
-    });
-    // Filter out empty lines that result from trailing newlines or
-    // multiple consecutive newlines in the source content.
-    const lines = wrapped.split("\n").filter((line) => line.length > 0);
-    // Ensure we always return at least one line (empty string for empty cells)
-    return lines.length > 0 ? lines : [""];
-}
-/**
- * Pad `content` to `targetWidth` according to alignment. `displayWidth` is the
- * visible width of `content` (caller computes this, e.g. via stringWidth on
- * ANSI-stripped text, so ANSI codes in `content` don't affect padding).
- */
-export function padAligned(content, displayWidth, targetWidth, align) {
-    const padding = Math.max(0, targetWidth - displayWidth);
-    if (align === "center") {
-        const leftPad = Math.floor(padding / 2);
-        return " ".repeat(leftPad) + content + " ".repeat(padding - leftPad);
-    }
-    if (align === "right") {
-        return " ".repeat(padding) + content;
-    }
-    return content + " ".repeat(padding);
-}
-/**
- * Render a markdown table to a box-drawing ANSI string for the terminal.
- * Handles terminal width by:
- * 1. Calculating minimum column widths based on longest word
- * 2. Distributing available space proportionally
- * 3. Wrapping text within cells (no truncation)
- * 4. Falling back to a vertical key-value format when rows would be too
- *    tall or the table still overflows the terminal width
- *
- * @param token - marked table token
- * @param columns - terminal width
- * @param formatInline - formats inline tokens to an ANSI string (the caller
- *                       binds its marked parser so this module stays
- *                       parser-agnostic and directly testable)
- */
-export function renderMarkdownTable(token, columns, formatInline) {
-    // Format cell content to ANSI string
-    function formatCell(tokens) {
-        return tokens && tokens.length > 0 ? formatInline(tokens) : "";
-    }
-    // Get plain text (stripped of ANSI codes)
-    function getPlainText(tokens) {
-        return stripAnsiColors(formatCell(tokens));
-    }
-    // Get the longest word width in a cell (minimum width to avoid breaking words)
-    function getMinWidth(tokens) {
-        const text = getPlainText(tokens);
-        const words = text.split(/\s+/).filter((w) => w.length > 0);
-        if (words.length === 0)
-            return MIN_COLUMN_WIDTH;
-        return Math.max(...words.map((w) => stringWidth(w)), MIN_COLUMN_WIDTH);
-    }
-    // Get ideal width (full content without wrapping)
-    function getIdealWidth(tokens) {
-        return Math.max(stringWidth(getPlainText(tokens)), MIN_COLUMN_WIDTH);
-    }
-    // Step 1: Get minimum (longest word) and ideal (full content) widths
-    const minWidths = token.header.map((header, colIndex) => {
-        let maxMinWidth = getMinWidth(header.tokens);
-        for (const row of token.rows) {
-            maxMinWidth = Math.max(maxMinWidth, getMinWidth(row[colIndex]?.tokens));
-        }
-        return maxMinWidth;
-    });
-    const idealWidths = token.header.map((header, colIndex) => {
-        let maxIdeal = getIdealWidth(header.tokens);
-        for (const row of token.rows) {
-            maxIdeal = Math.max(maxIdeal, getIdealWidth(row[colIndex]?.tokens));
-        }
-        return maxIdeal;
-    });
-    // Step 2: Calculate available space
-    // Border overhead: │ content │ content │ = 1 + (width + 3) per column
-    const numCols = token.header.length;
-    const borderOverhead = 1 + numCols * 3; // │ + (2 padding + 1 border) per col
-    // Account for SAFETY_MARGIN to avoid triggering the fallback safety check
-    const availableWidth = Math.max(columns - borderOverhead - SAFETY_MARGIN, numCols * MIN_COLUMN_WIDTH);
-    // Step 3: Calculate column widths that fit available space
-    const totalMin = minWidths.reduce((sum, w) => sum + w, 0);
-    const totalIdeal = idealWidths.reduce((sum, w) => sum + w, 0);
-    // Track whether columns are narrower than longest words (needs hard wrap)
-    let needsHardWrap = false;
-    let columnWidths;
-    if (totalIdeal <= availableWidth) {
-        // Everything fits - use ideal widths
-        columnWidths = idealWidths;
-    }
-    else if (totalMin <= availableWidth) {
-        // Need to shrink - give each column its min, distribute remaining space
-        const extraSpace = availableWidth - totalMin;
-        const overflows = idealWidths.map((ideal, i) => ideal - minWidths[i]);
-        const totalOverflow = overflows.reduce((sum, o) => sum + o, 0);
-        columnWidths = minWidths.map((min, i) => {
-            if (totalOverflow === 0)
-                return min;
-            const extra = Math.floor((overflows[i] / totalOverflow) * extraSpace);
-            return min + extra;
-        });
-    }
-    else {
-        // Table wider than terminal at minimum widths
-        // Shrink columns proportionally to fit allowing word breaks
-        needsHardWrap = true;
-        const scaleFactor = availableWidth / totalMin;
-        columnWidths = minWidths.map((w) => Math.max(Math.floor(w * scaleFactor), MIN_COLUMN_WIDTH));
-    }
-    // Step 4: Calculate max row lines to determine if vertical format is needed
-    function calculateMaxRowLines() {
-        let maxLines = 1;
-        // Check header
-        for (let i = 0; i < token.header.length; i++) {
-            const content = formatCell(token.header[i].tokens);
-            const wrapped = wrapText(content, columnWidths[i], {
-                hard: needsHardWrap,
-            });
-            maxLines = Math.max(maxLines, wrapped.length);
-        }
-        // Check rows
-        for (const row of token.rows) {
-            for (let i = 0; i < row.length; i++) {
-                const content = formatCell(row[i]?.tokens);
-                const wrapped = wrapText(content, columnWidths[i], {
-                    hard: needsHardWrap,
-                });
-                maxLines = Math.max(maxLines, wrapped.length);
-            }
-        }
-        return maxLines;
-    }
-    // Use vertical format if wrapping would make rows too tall
-    const maxRowLines = calculateMaxRowLines();
-    const useVerticalFormat = maxRowLines > MAX_ROW_LINES;
-    // Render a single row with potential multi-line cells
-    // Returns an array of strings, one per line of the row
-    function renderRowLines(cells, isHeader) {
-        // Get wrapped lines for each cell (preserving ANSI formatting)
-        const cellLines = cells.map((cell, colIndex) => {
-            const formattedText = formatCell(cell.tokens);
-            const width = columnWidths[colIndex];
-            return wrapText(formattedText, width, { hard: needsHardWrap });
-        });
-        // Find max number of lines in this row
-        const maxLines = Math.max(...cellLines.map((lines) => lines.length), 1);
-        // Calculate vertical offset for each cell (to center vertically)
-        const verticalOffsets = cellLines.map((lines) => Math.floor((maxLines - lines.length) / 2));
-        // Build each line of the row as a single string
-        const result = [];
-        for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
-            let line = "│";
-            for (let colIndex = 0; colIndex < cells.length; colIndex++) {
-                const lines = cellLines[colIndex];
-                const offset = verticalOffsets[colIndex];
-                const contentLineIdx = lineIdx - offset;
-                const lineText = contentLineIdx >= 0 && contentLineIdx < lines.length
-                    ? lines[contentLineIdx]
-                    : "";
-                const width = columnWidths[colIndex];
-                // Headers always centered; data uses table alignment
-                const align = isHeader
-                    ? "center"
-                    : (token.align?.[colIndex] ?? "left");
-                line +=
-                    " " +
-                        padAligned(lineText, stringWidth(lineText), width, align) +
-                        " │";
-            }
-            result.push(line);
-        }
-        return result;
-    }
-    // Render horizontal border as a single string
-    function renderBorderLine(type) {
-        const [left, mid, cross, right] = {
-            top: ["┌", "─", "┬", "┐"],
-            middle: ["├", "─", "┼", "┤"],
-            bottom: ["└", "─", "┴", "┘"],
-        }[type];
-        let line = left;
-        columnWidths.forEach((width, colIndex) => {
-            line += mid.repeat(width + 2);
-            line += colIndex < columnWidths.length - 1 ? cross : right;
-        });
-        return line;
-    }
-    // Render vertical format (key-value pairs) for extra-narrow terminals
-    function renderVerticalFormat() {
-        const lines = [];
-        const headers = token.header.map((h) => getPlainText(h.tokens));
-        const separatorWidth = Math.min(columns - 1, 40);
-        const separator = "─".repeat(separatorWidth);
-        // Small indent for wrapped lines (just 2 spaces)
-        const wrapIndent = "  ";
-        token.rows.forEach((row, rowIndex) => {
-            if (rowIndex > 0) {
-                lines.push(separator);
-            }
-            row.forEach((cell, colIndex) => {
-                const label = headers[colIndex] || `Column ${colIndex + 1}`;
-                // Clean value: trim, remove extra internal whitespace/newlines
-                const rawValue = formatCell(cell.tokens).trimEnd();
-                const value = rawValue.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
-                // Wrap value to fit terminal, accounting for label on first line
-                const firstLineWidth = columns - stringWidth(label) - 3;
-                const subsequentLineWidth = columns - wrapIndent.length - 1;
-                // Two-pass wrap: first line is narrower (label takes space),
-                // continuation lines get the full width minus indent.
-                const firstPassLines = wrapText(value, Math.max(firstLineWidth, 10));
-                const firstLine = firstPassLines[0] || "";
-                let wrappedValue;
-                if (firstPassLines.length <= 1 ||
-                    subsequentLineWidth <= firstLineWidth) {
-                    wrappedValue = firstPassLines;
-                }
-                else {
-                    // Re-join remaining text and re-wrap to the wider continuation width
-                    const remainingText = firstPassLines
-                        .slice(1)
-                        .map((l) => l.trim())
-                        .join(" ");
-                    const rewrapped = wrapText(remainingText, subsequentLineWidth);
-                    wrappedValue = [firstLine, ...rewrapped];
-                }
-                // First line: bold label + value
-                lines.push(`${ANSI_BOLD_START}${label}:${ANSI_BOLD_END} ${wrappedValue[0] || ""}`);
-                // Subsequent lines with small indent (skip empty lines)
-                for (let i = 1; i < wrappedValue.length; i++) {
-                    const line = wrappedValue[i];
-                    if (!line.trim())
-                        continue;
-                    lines.push(`${wrapIndent}${line}`);
-                }
-            });
-        });
-        return lines.join("\n");
-    }
-    // Choose format based on available width
-    if (useVerticalFormat) {
-        return renderVerticalFormat();
-    }
-    // Build the complete horizontal table as an array of strings
-    const tableLines = [];
-    tableLines.push(renderBorderLine("top"));
-    tableLines.push(...renderRowLines(token.header, true));
-    tableLines.push(renderBorderLine("middle"));
-    token.rows.forEach((row, rowIndex) => {
-        tableLines.push(...renderRowLines(row, false));
-        if (rowIndex < token.rows.length - 1) {
-            tableLines.push(renderBorderLine("middle"));
-        }
-    });
-    tableLines.push(renderBorderLine("bottom"));
-    // Safety check: verify no line exceeds terminal width.
-    // This catches edge cases during terminal resize where calculations
-    // were based on a different width than the current render target.
-    const maxLineWidth = Math.max(...tableLines.map((line) => stringWidth(stripAnsiColors(line))));
-    // If we're within SAFETY_MARGIN characters of the edge, use vertical format
-    // to account for terminal resize race conditions.
-    if (maxLineWidth > columns - SAFETY_MARGIN) {
-        return renderVerticalFormat();
-    }
-    return tableLines.join("\n");
-}

package/dist/utils/rewindCheckpoints.d.ts

@@ -1,8 +0,0 @@
-import type { Message } from "wave-agent-sdk";
-/**
- * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
- * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
- * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
- */
-export declare function isUserCheckpointMessage(m: Message): boolean;

package/dist/utils/rewindCheckpoints.js

@@ -1,17 +0,0 @@
-/**
- * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
- * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
- * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
- */
-export function isUserCheckpointMessage(m) {
-    if (m.role !== "user" || m.isMeta)
-        return false;
-    if (m.blocks.some((b) => b.type === "task_notification"))
-        return false;
-    if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
-        return false;
-    if (m.blocks.some((b) => b.type === "bang"))
-        return false;
-    return true;
-}

package/dist/utils/throttle.d.ts

@@ -1,14 +0,0 @@
-export interface ThrottleOptions {
-    leading?: boolean;
-    trailing?: boolean;
-}
-export interface ThrottledFunction<A extends unknown[]> {
-    (...args: A): void;
-    cancel: () => void;
-    flush: () => void;
-}
-/**
- * Creates a throttled function that only invokes `func` at most once per
- * every `wait` milliseconds.
- */
-export declare function throttle<A extends unknown[]>(func: (...args: A) => void, wait: number, options?: ThrottleOptions): ThrottledFunction<A>;

package/dist/utils/throttle.js

@@ -1,55 +0,0 @@
-/**
- * Creates a throttled function that only invokes `func` at most once per
- * every `wait` milliseconds.
- */
-export function throttle(func, wait, options = { leading: true, trailing: true }) {
-    let timeoutId = null;
-    let lastArgs = null;
-    let lastCallTime = 0;
-    const invokeFunc = () => {
-        if (lastArgs) {
-            func(...lastArgs);
-            lastCallTime = Date.now();
-            lastArgs = null;
-        }
-    };
-    const throttled = (...args) => {
-        const now = Date.now();
-        const remaining = wait - (now - lastCallTime);
-        lastArgs = args;
-        if (remaining <= 0 || remaining > wait) {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-                timeoutId = null;
-            }
-            if (options.leading !== false || lastCallTime !== 0) {
-                invokeFunc();
-            }
-            else {
-                lastCallTime = now;
-            }
-        }
-        else if (!timeoutId && options.trailing !== false) {
-            timeoutId = setTimeout(() => {
-                timeoutId = null;
-                invokeFunc();
-            }, remaining);
-        }
-    };
-    throttled.cancel = () => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-        lastArgs = null;
-        lastCallTime = 0;
-    };
-    throttled.flush = () => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-        invokeFunc();
-    };
-    return throttled;
-}

package/dist/utils/toolParameterTransforms.d.ts

@@ -1,18 +0,0 @@
-/**
- * Tool parameter transformation utilities for UI rendering
- * Forces type judgment based on tool name using type assertions
- */
-import { type Change, type WriteToolParameters, type EditToolParameters } from "wave-agent-sdk";
-/**
- * Transform Write tool parameters to changes
- */
-export declare function transformWriteParameters(parameters: WriteToolParameters): Change[];
-/**
- * Transform Edit tool parameters to changes
- */
-export declare function transformEditParameters(parameters: EditToolParameters): Change[];
-/**
- * Transform tool block parameters into standardized Change[] array for diff display
- * Forces type judgment based on tool name using type assertions
- */
-export declare function transformToolBlockToChanges(toolName: string, parameters: string, startLineNumber?: number): Change[];

package/dist/utils/toolParameterTransforms.js

@@ -1,73 +0,0 @@
-/**
- * Tool parameter transformation utilities for UI rendering
- * Forces type judgment based on tool name using type assertions
- */
-import { logger } from "./logger.js";
-/**
- * Parse tool block parameters
- */
-function parseToolParameters(parameters) {
-    if (!parameters) {
-        return {};
-    }
-    try {
-        return JSON.parse(parameters);
-    }
-    catch (error) {
-        logger.warn("Failed to parse tool parameters:", error);
-        return {};
-    }
-}
-/**
- * Transform Write tool parameters to changes
- */
-export function transformWriteParameters(parameters) {
-    return [
-        {
-            oldContent: "", // No previous content for write operations
-            newContent: parameters.content,
-        },
-    ];
-}
-/**
- * Transform Edit tool parameters to changes
- */
-export function transformEditParameters(parameters) {
-    return [
-        {
-            oldContent: parameters.old_string,
-            newContent: parameters.new_string,
-        },
-    ];
-}
-/**
- * Transform tool block parameters into standardized Change[] array for diff display
- * Forces type judgment based on tool name using type assertions
- */
-export function transformToolBlockToChanges(toolName, parameters, startLineNumber) {
-    try {
-        if (!toolName) {
-            return [];
-        }
-        const parsedParams = parseToolParameters(parameters);
-        let changes = [];
-        switch (toolName) {
-            case "Write":
-                changes = transformWriteParameters(parsedParams);
-                break;
-            case "Edit":
-                changes = transformEditParameters(parsedParams);
-                break;
-            default:
-                return [];
-        }
-        if (changes.length > 0 && startLineNumber !== undefined) {
-            changes[0].startLineNumber = startLineNumber;
-        }
-        return changes;
-    }
-    catch (error) {
-        logger.warn("Failed to transform tool block to changes:", error);
-        return [];
-    }
-}

package/dist/utils/usageSummary.d.ts

@@ -1,28 +0,0 @@
-import type { Usage } from "wave-agent-sdk";
-/**
- * Token summary by model
- */
-export interface TokenSummary {
-    model: string;
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-    operations: {
-        agent_calls: number;
-        compactions: number;
-    };
-    cache_read_input_tokens?: number;
-    cache_creation_input_tokens?: number;
-}
-/**
- * Calculate token usage summary by model from usage array
- * @param usages Array of usage data from agent operations
- * @returns Array of token summaries grouped by model
- */
-export declare function calculateTokenSummary(usages: Usage[]): Record<string, TokenSummary>;
-/**
- * Display usage summary in a formatted way
- * @param usages Array of usage data from agent operations
- * @param sessionFilePath Optional session file path to display
- */
-export declare function displayUsageSummary(usages: Usage[], sessionFilePath?: string): void;

package/dist/utils/usageSummary.js

@@ -1,121 +0,0 @@
-/**
- * Calculate token usage summary by model from usage array
- * @param usages Array of usage data from agent operations
- * @returns Array of token summaries grouped by model
- */
-export function calculateTokenSummary(usages) {
-    const summaryMap = new Map();
-    for (const usage of usages) {
-        const model = usage.model || "unknown";
-        if (!summaryMap.has(model)) {
-            summaryMap.set(model, {
-                model,
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
-                operations: {
-                    agent_calls: 0,
-                    compactions: 0,
-                },
-            });
-        }
-        const summary = summaryMap.get(model);
-        summary.prompt_tokens += usage.prompt_tokens;
-        summary.completion_tokens += usage.completion_tokens;
-        summary.total_tokens += usage.total_tokens;
-        // Handle cache tokens if present and non-zero
-        if (usage.cache_read_input_tokens && usage.cache_read_input_tokens > 0) {
-            summary.cache_read_input_tokens =
-                (summary.cache_read_input_tokens || 0) + usage.cache_read_input_tokens;
-        }
-        if (usage.cache_creation_input_tokens &&
-            usage.cache_creation_input_tokens > 0) {
-            summary.cache_creation_input_tokens =
-                (summary.cache_creation_input_tokens || 0) +
-                    usage.cache_creation_input_tokens;
-        }
-        // Track operation types
-        if (usage.operation_type === "agent") {
-            summary.operations.agent_calls += 1;
-        }
-        else if (usage.operation_type === "compact") {
-            summary.operations.compactions += 1;
-        }
-    }
-    // Convert Map to Record and sort by total tokens
-    const result = {};
-    const sortedEntries = Array.from(summaryMap.entries()).sort((a, b) => b[1].total_tokens - a[1].total_tokens);
-    for (const [model, summary] of sortedEntries) {
-        result[model] = summary;
-    }
-    return result;
-}
-/**
- * Display usage summary in a formatted way
- * @param usages Array of usage data from agent operations
- * @param sessionFilePath Optional session file path to display
- */
-export function displayUsageSummary(usages, sessionFilePath) {
-    if (usages.length === 0) {
-        return; // No usage data to display
-    }
-    const summaries = calculateTokenSummary(usages);
-    console.log("\nToken Usage Summary:");
-    console.log("==================");
-    if (sessionFilePath) {
-        console.log(`Session: ${sessionFilePath}`);
-    }
-    let totalPrompt = 0;
-    let totalCompletion = 0;
-    let totalTokens = 0;
-    let totalAgentCalls = 0;
-    let totalCompactions = 0;
-    let totalCacheRead = 0;
-    let totalCacheCreation = 0;
-    let hasCacheData = false;
-    for (const [, summary] of Object.entries(summaries)) {
-        console.log(`Model: ${summary.model}`);
-        console.log(`  Prompt tokens: ${summary.prompt_tokens.toLocaleString()}`);
-        console.log(`  Completion tokens: ${summary.completion_tokens.toLocaleString()}`);
-        console.log(`  Total tokens: ${summary.total_tokens.toLocaleString()}`);
-        // Display cache information if available
-        if (summary.cache_read_input_tokens ||
-            summary.cache_creation_input_tokens) {
-            hasCacheData = true;
-            console.log("  Cache Usage:");
-            if (summary.cache_read_input_tokens &&
-                summary.cache_read_input_tokens > 0) {
-                console.log(`    Read from cache: ${summary.cache_read_input_tokens.toLocaleString()} tokens`);
-                totalCacheRead += summary.cache_read_input_tokens;
-            }
-            if (summary.cache_creation_input_tokens &&
-                summary.cache_creation_input_tokens > 0) {
-                console.log(`    Created cache: ${summary.cache_creation_input_tokens.toLocaleString()} tokens`);
-                totalCacheCreation += summary.cache_creation_input_tokens;
-            }
-        }
-        console.log(`  Operations: ${summary.operations.agent_calls} agent calls, ${summary.operations.compactions} compactions`);
-        console.log();
-        totalPrompt += summary.prompt_tokens;
-        totalCompletion += summary.completion_tokens;
-        totalTokens += summary.total_tokens;
-        totalAgentCalls += summary.operations.agent_calls;
-        totalCompactions += summary.operations.compactions;
-    }
-    if (Object.keys(summaries).length > 1) {
-        console.log("Overall Total:");
-        console.log(`  Prompt tokens: ${totalPrompt.toLocaleString()}`);
-        console.log(`  Completion tokens: ${totalCompletion.toLocaleString()}`);
-        console.log(`  Total tokens: ${totalTokens.toLocaleString()}`);
-        if (hasCacheData) {
-            console.log("  Cache Usage:");
-            if (totalCacheRead > 0) {
-                console.log(`    Read from cache: ${totalCacheRead.toLocaleString()} tokens`);
-            }
-            if (totalCacheCreation > 0) {
-                console.log(`    Created cache: ${totalCacheCreation.toLocaleString()} tokens`);
-            }
-        }
-        console.log(`  Operations: ${totalAgentCalls} agent calls, ${totalCompactions} compactions`);
-    }
-}

package/dist/utils/version.d.ts

@@ -1 +0,0 @@
-export declare function isUpdateAvailable(currentVersion: string, latestVersion: string): boolean;

package/dist/utils/version.js

@@ -1,4 +0,0 @@
-import semver from "semver";
-export function isUpdateAvailable(currentVersion, latestVersion) {
-    return semver.gt(latestVersion, currentVersion);
-}