snow-ai 0.4.16 → 0.4.17

package/dist/ui/components/UsagePanel.js

@@ -1,394 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { useTerminalSize } from '../../hooks/useTerminalSize.js';
-const GRANULARITY_LABELS = {
-    hour: 'Last 24h',
-    day: 'Last 7d',
-    week: 'Last 30d',
-    month: 'Last 12m',
-};
-function getModelShortName(modelName, maxLength = 20) {
-    // Extract readable name from model string intelligently
-    // Examples:
-    // "claude-sonnet-4-5-20250929" -> "Sonnet 4.5"
-    // "gpt-4-turbo-2024-04-09" -> "GPT-4 Turbo"
-    // "deepseek-chat-v2.5" -> "Deepseek Chat V2.5"
-    // "glm-4-plus-20240116" -> "GLM-4 Plus"
-    // "qwen2.5-72b-instruct" -> "Qwen2.5 72B"
-    let name = modelName;
-    // Step 1: Remove common date/version suffixes
-    // Remove YYYYMMDD dates
-    name = name.replace(/-?\d{8}$/g, '');
-    // Remove YYYY-MM-DD dates
-    name = name.replace(/-\d{4}-\d{2}-\d{2}$/g, '');
-    // Remove trailing version hashes
-    name = name.replace(/-[a-f0-9]{7,}$/gi, '');
-    // Step 2: Convert version patterns (4-5 -> 4.5, but keep word-number like gpt-4)
-    // Only convert digit-digit patterns
-    name = name.replace(/(\d)-(\d)/g, '$1.$2');
-    // Step 3: Smart parsing based on common patterns
-    const parts = name.split(/[-_]/);
-    // Filter out common suffixes we don't want
-    const stopWords = [
-        'instruct',
-        'chat',
-        'base',
-        'turbo',
-        'preview',
-        'api',
-        'model',
-    ];
-    const importantParts = [];
-    const suffixParts = [];
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (!part)
-            continue;
-        const lower = part.toLowerCase();
-        // First part is always important (brand name)
-        if (i === 0) {
-            importantParts.push(part);
-            continue;
-        }
-        // Version numbers and model tiers are important
-        if (/^\d+\.?\d*[a-z]?$/i.test(part) || /^v\d/i.test(part)) {
-            importantParts.push(part);
-            continue;
-        }
-        // Size indicators (72b, 7b, etc)
-        if (/^\d+[bm]$/i.test(part)) {
-            importantParts.push(part.toUpperCase());
-            continue;
-        }
-        // Model names/variants (sonnet, haiku, plus, pro, ultra, etc)
-        if (lower.match(/^(sonnet|haiku|opus|plus|pro|ultra|mini|nano|max|lite)$/)) {
-            importantParts.push(part);
-            continue;
-        }
-        // Common suffixes go to end
-        if (stopWords.includes(lower)) {
-            suffixParts.push(part);
-            continue;
-        }
-        // Everything else goes to important parts (up to 3 parts total)
-        if (importantParts.length < 3) {
-            importantParts.push(part);
-        }
-    }
-    // Step 4: Format the name
-    let result = importantParts
-        .map((part, idx) => {
-        // First part: capitalize first letter
-        if (idx === 0) {
-            return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-        }
-        // Version numbers and sizes: keep as-is or uppercase
-        if (/^\d|^v\d|^\d+[BM]$/i.test(part)) {
-            return part;
-        }
-        // Other parts: capitalize first letter
-        return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-    })
-        .join(' ');
-    // Add important suffix if exists and space allows
-    if (suffixParts.length > 0 &&
-        suffixParts[0] &&
-        result.length < maxLength - 5) {
-        result +=
-            ' ' +
-                suffixParts[0].charAt(0).toUpperCase() +
-                suffixParts[0].slice(1).toLowerCase();
-    }
-    // Step 5: Truncate if too long
-    return result.length > maxLength ? result.slice(0, maxLength) : result;
-}
-async function loadUsageData() {
-    const homeDir = os.homedir();
-    const usageDir = path.join(homeDir, '.snow', 'usage');
-    try {
-        const entries = [];
-        const dateDirs = await fs.readdir(usageDir);
-        for (const dateDir of dateDirs) {
-            const datePath = path.join(usageDir, dateDir);
-            const stats = await fs.stat(datePath);
-            if (!stats.isDirectory())
-                continue;
-            const files = await fs.readdir(datePath);
-            for (const file of files) {
-                if (!file.endsWith('.jsonl'))
-                    continue;
-                const filePath = path.join(datePath, file);
-                const content = await fs.readFile(filePath, 'utf-8');
-                const lines = content
-                    .trim()
-                    .split('\n')
-                    .filter(l => l.trim());
-                for (const line of lines) {
-                    try {
-                        const entry = JSON.parse(line);
-                        entries.push(entry);
-                    }
-                    catch {
-                        // Skip invalid lines
-                    }
-                }
-            }
-        }
-        return entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-    }
-    catch (error) {
-        return [];
-    }
-}
-function filterByGranularity(entries, granularity) {
-    if (entries.length === 0)
-        return [];
-    const now = new Date();
-    const cutoff = new Date(now);
-    switch (granularity) {
-        case 'hour':
-            cutoff.setHours(now.getHours() - 24);
-            break;
-        case 'day':
-            cutoff.setDate(now.getDate() - 7);
-            break;
-        case 'week':
-            cutoff.setDate(now.getDate() - 30);
-            break;
-        case 'month':
-            cutoff.setMonth(now.getMonth() - 12);
-            break;
-    }
-    return entries.filter(e => new Date(e.timestamp) >= cutoff);
-}
-function aggregateByModel(entries) {
-    const models = new Map();
-    let grandTotal = 0;
-    for (const entry of entries) {
-        const modelName = entry.model;
-        if (!models.has(modelName)) {
-            models.set(modelName, {
-                input: 0,
-                output: 0,
-                cacheCreation: 0,
-                cacheRead: 0,
-                total: 0,
-            });
-        }
-        const stats = models.get(modelName);
-        stats.input += entry.inputTokens;
-        stats.output += entry.outputTokens;
-        stats.cacheCreation += entry.cacheCreationInputTokens || 0;
-        stats.cacheRead += entry.cacheReadInputTokens || 0;
-        stats.total += entry.inputTokens + entry.outputTokens;
-        grandTotal += entry.inputTokens + entry.outputTokens;
-    }
-    return { models, grandTotal };
-}
-function formatTokens(tokens, compact = false) {
-    if (tokens >= 1000000) {
-        return compact
-            ? `${(tokens / 1000000).toFixed(1)}M`
-            : `${(tokens / 1000000).toFixed(2)}M`;
-    }
-    if (tokens >= 1000) {
-        return compact
-            ? `${Math.round(tokens / 1000)}K`
-            : `${(tokens / 1000).toFixed(1)}K`;
-    }
-    return String(tokens);
-}
-function renderStackedBarChart(stats, terminalWidth, scrollOffset) {
-    if (stats.models.size === 0) {
-        return (React.createElement(Text, { color: "gray", dimColor: true }, "No data available"));
-    }
-    const sortedModels = Array.from(stats.models.entries()).sort((a, b) => b[1].total - a[1].total);
-    const isNarrow = terminalWidth < 100;
-    // Show maximum 2 models at a time for better readability
-    const maxVisibleModels = 2;
-    // Calculate visible range
-    const startIdx = scrollOffset;
-    const endIdx = Math.min(startIdx + maxVisibleModels, sortedModels.length);
-    const visibleModels = sortedModels.slice(startIdx, endIdx);
-    const hasMoreAbove = startIdx > 0;
-    const hasMoreBelow = endIdx < sortedModels.length;
-    // Calculate max total (including cache) for scaling
-    const maxTotal = Math.max(...Array.from(stats.models.values()).map(s => s.total + s.cacheCreation + s.cacheRead));
-    // Use almost full width for bars (leave some margin)
-    const maxBarWidth = Math.min(isNarrow ? 50 : 70, terminalWidth - 10);
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "cyan" }, "\u2588"),
-            React.createElement(Text, { color: "gray", dimColor: true },
-                ' ',
-                "Usage",
-                ' '),
-            React.createElement(Text, { color: "green" }, "\u2588"),
-            React.createElement(Text, { color: "gray", dimColor: true },
-                ' ',
-                "Cache Hit",
-                ' '),
-            React.createElement(Text, { color: "yellow" }, "\u2588"),
-            React.createElement(Text, { color: "gray", dimColor: true },
-                ' ',
-                "Cache Create")),
-        hasMoreAbove && (React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "yellow", dimColor: true },
-                "\u2191 ",
-                startIdx,
-                " more above (use \u2191 arrow)"))),
-        visibleModels.map(([modelName, modelStats]) => {
-            const shortName = getModelShortName(modelName, 30);
-            // Calculate segment lengths based on proportion
-            // Ensure at least 1 character if value exists
-            const usageLength = modelStats.total > 0
-                ? Math.max(1, Math.round((modelStats.total / maxTotal) * maxBarWidth))
-                : 0;
-            const cacheHitLength = modelStats.cacheRead > 0
-                ? Math.max(1, Math.round((modelStats.cacheRead / maxTotal) * maxBarWidth))
-                : 0;
-            const cacheCreateLength = modelStats.cacheCreation > 0
-                ? Math.max(1, Math.round((modelStats.cacheCreation / maxTotal) * maxBarWidth))
-                : 0;
-            return (React.createElement(Box, { key: modelName, flexDirection: "column", marginBottom: 1 },
-                React.createElement(Box, null,
-                    React.createElement(Text, { bold: true, color: "white" }, shortName)),
-                React.createElement(Box, null,
-                    usageLength > 0 && (React.createElement(Text, { color: "cyan" }, '█'.repeat(usageLength))),
-                    cacheHitLength > 0 && (React.createElement(Text, { color: "green" }, '█'.repeat(cacheHitLength))),
-                    cacheCreateLength > 0 && (React.createElement(Text, { color: "yellow" }, '█'.repeat(cacheCreateLength)))),
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: "cyan" },
-                        "Usage: ",
-                        formatTokens(modelStats.total, isNarrow)),
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        ' ',
-                        "(In: ",
-                        formatTokens(modelStats.input, isNarrow),
-                        ", Out:",
-                        ' ',
-                        formatTokens(modelStats.output, isNarrow),
-                        ")"),
-                    (modelStats.cacheRead > 0 || modelStats.cacheCreation > 0) && (React.createElement(React.Fragment, null,
-                        React.createElement(Text, { color: "gray", dimColor: true },
-                            ' ',
-                            "|",
-                            ' '),
-                        modelStats.cacheRead > 0 && (React.createElement(React.Fragment, null,
-                            React.createElement(Text, { color: "green" },
-                                "Hit: ",
-                                formatTokens(modelStats.cacheRead, isNarrow)),
-                            modelStats.cacheCreation > 0 && (React.createElement(Text, { color: "gray", dimColor: true },
-                                ",",
-                                ' ')))),
-                        modelStats.cacheCreation > 0 && (React.createElement(Text, { color: "yellow" },
-                            "Create: ",
-                            formatTokens(modelStats.cacheCreation, isNarrow))))))));
-        }),
-        sortedModels.length > 1 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-            React.createElement(Text, { color: "gray", dimColor: true }, '─'.repeat(Math.min(terminalWidth - 8, 70))),
-            React.createElement(Box, null,
-                React.createElement(Text, { bold: true, color: "white" },
-                    "TOTAL:",
-                    ' '),
-                React.createElement(Text, { color: "cyan", bold: true }, formatTokens(stats.grandTotal)),
-                Array.from(stats.models.values()).reduce((sum, s) => sum + s.cacheRead, 0) > 0 && (React.createElement(React.Fragment, null,
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        ' ',
-                        "|",
-                        ' '),
-                    React.createElement(Text, { color: "green", bold: true },
-                        "Hit:",
-                        ' ',
-                        formatTokens(Array.from(stats.models.values()).reduce((sum, s) => sum + s.cacheRead, 0))))),
-                Array.from(stats.models.values()).reduce((sum, s) => sum + s.cacheCreation, 0) > 0 && (React.createElement(React.Fragment, null,
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        ",",
-                        ' '),
-                    React.createElement(Text, { color: "yellow", bold: true },
-                        "Create:",
-                        ' ',
-                        formatTokens(Array.from(stats.models.values()).reduce((sum, s) => sum + s.cacheCreation, 0)))))))),
-        hasMoreBelow && (React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { color: "yellow", dimColor: true },
-                "\u2193 ",
-                sortedModels.length - endIdx,
-                " more below (use \u2193 arrow)")))));
-}
-export default function UsagePanel() {
-    const [granularity, setGranularity] = useState('week');
-    const [stats, setStats] = useState({
-        models: new Map(),
-        grandTotal: 0,
-    });
-    const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState(null);
-    const [scrollOffset, setScrollOffset] = useState(0);
-    const { columns: terminalWidth } = useTerminalSize();
-    useEffect(() => {
-        const load = async () => {
-            setIsLoading(true);
-            try {
-                const entries = await loadUsageData();
-                const filtered = filterByGranularity(entries, granularity);
-                const aggregated = aggregateByModel(filtered);
-                setStats(aggregated);
-                setError(null);
-            }
-            catch (err) {
-                setError(err instanceof Error ? err.message : 'Failed to load usage data');
-            }
-            finally {
-                setIsLoading(false);
-            }
-        };
-        load();
-    }, [granularity]);
-    // Reset scroll when changing granularity
-    useEffect(() => {
-        setScrollOffset(0);
-    }, [granularity]);
-    useInput((_input, key) => {
-        if (key.tab) {
-            const granularities = ['hour', 'day', 'week', 'month'];
-            const currentIdx = granularities.indexOf(granularity);
-            const nextIdx = (currentIdx + 1) % granularities.length;
-            setGranularity(granularities[nextIdx]);
-        }
-        // Calculate available space for scrolling
-        const sortedModels = Array.from(stats.models.entries()).sort((a, b) => b[1].total - a[1].total);
-        const totalModels = sortedModels.length;
-        if (key.upArrow) {
-            setScrollOffset(prev => Math.max(0, prev - 1));
-        }
-        if (key.downArrow) {
-            // Reserve space for header, legend, total summary
-            const maxScroll = Math.max(0, totalModels - 1);
-            setScrollOffset(prev => Math.min(maxScroll, prev + 1));
-        }
-    });
-    if (isLoading) {
-        return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "gray" }, "Loading usage statistics...")));
-    }
-    if (error) {
-        return (React.createElement(Box, { borderColor: "red", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "red" },
-                "Error: ",
-                error)));
-    }
-    return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 1, flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "cyan", bold: true }, "Token Usage Statistics"),
-            React.createElement(Text, { color: "gray" },
-                " (",
-                GRANULARITY_LABELS[granularity],
-                ")"),
-            React.createElement(Text, { color: "gray", dimColor: true },
-                ' ',
-                "- Tab to switch")),
-        stats.models.size === 0 ? (React.createElement(Text, { color: "gray", dimColor: true }, "No usage data for this period")) : (renderStackedBarChart(stats, terminalWidth, scrollOffset))));
-}

package/dist/ui/contexts/ThemeContext.d.ts

@@ -1,13 +0,0 @@
-import React, { ReactNode } from 'react';
-import { ThemeType, Theme } from '../themes/index.js';
-interface ThemeContextType {
-    theme: Theme;
-    themeType: ThemeType;
-    setThemeType: (type: ThemeType) => void;
-}
-interface ThemeProviderProps {
-    children: ReactNode;
-}
-export declare function ThemeProvider({ children }: ThemeProviderProps): React.JSX.Element;
-export declare function useTheme(): ThemeContextType;
-export {};

package/dist/ui/contexts/ThemeContext.js

@@ -1,28 +0,0 @@
-import React, { createContext, useContext, useState, } from 'react';
-import { themes } from '../themes/index.js';
-import { getCurrentTheme, setCurrentTheme, } from '../../utils/themeConfig.js';
-const ThemeContext = createContext(undefined);
-export function ThemeProvider({ children }) {
-    const [themeType, setThemeTypeState] = useState(() => {
-        // Load initial theme from config
-        return getCurrentTheme();
-    });
-    const setThemeType = (type) => {
-        setThemeTypeState(type);
-        // Persist to config file
-        setCurrentTheme(type);
-    };
-    const value = {
-        theme: themes[themeType],
-        themeType,
-        setThemeType,
-    };
-    return (React.createElement(ThemeContext.Provider, { value: value }, children));
-}
-export function useTheme() {
-    const context = useContext(ThemeContext);
-    if (!context) {
-        throw new Error('useTheme must be used within a ThemeProvider');
-    }
-    return context;
-}

package/dist/ui/pages/ChatScreen.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-type Props = {
-    skipWelcome?: boolean;
-};
-export default function ChatScreen({ skipWelcome }: Props): React.JSX.Element;
-export {};