opencode-tokenwatch 0.1.0 → 0.2.0

package/dist/i18n.d.ts

@@ -0,0 +1,5 @@
+export type SupportedLanguage = "zh" | "en";
+export declare function detectLanguage(): SupportedLanguage;
+export declare function setLanguage(lang: SupportedLanguage | "auto"): void;
+export declare function getCurrentLanguage(): SupportedLanguage;
+export declare function t(key: string): string;

package/dist/i18n.js

@@ -0,0 +1,175 @@
+const zh = {
+    panelTitle: "TokenWatch",
+    collapse: "折叠",
+    expand: "展开",
+    sessionSummary: "会话累计",
+    input: "输入",
+    output: "输出",
+    cacheRead: "缓存",
+    cacheWrite: "缓存写",
+    cacheMiss: "未命中",
+    hitRate: "命中率",
+    requests: "请求",
+    cost: "成本",
+    trendUp: "↑",
+    trendDown: "↓",
+    cache: "缓存",
+    performance: "性能",
+    pricing: "Pricing",
+    tokenDistribution: "Token分布",
+    modelLabel: "模型",
+    provider: "提供商",
+    ttft: "TTFT",
+    tps: "TPS",
+    latency: "延迟",
+    avg: "平均",
+    max: "最大",
+    min: "最小",
+    read: "读",
+    write: "写",
+    sessionAccumulated: "Session累计",
+    saving: "节省",
+    priceInput: "输入",
+    priceCacheRead: "缓存读",
+    priceCacheWrite: "缓存写",
+    priceOutput: "输出",
+    total: "总计",
+    system: "系统提示",
+    user: "用户",
+    agent: "Agent指令",
+    toolCall: "Tool调用",
+    toolResult: "Tool结果",
+    outputTokens: "输出",
+    settings: "Settings",
+    showCache: "显示缓存统计",
+    showPerformance: "显示性能指标",
+    showPricing: "显示模型定价",
+    showTokenDistribution: "显示Token分布",
+    showTrend: "显示趋势指示器",
+    language: "语言",
+    auto: "自动",
+    cmdTitleHtml: "HTML报告",
+    cmdDescHtml: "生成交互式HTML仪表盘，展示Token用量、缓存和性能图表",
+    cmdTitleJson: "JSON导出",
+    cmdDescJson: "导出原始用量数据为JSON文件",
+    cmdTitleText: "文本报告",
+    cmdDescText: "生成纯文本报告文件",
+    cmdTitleSettings: "设置",
+    cmdDescSettings: "配置侧边栏显示选项",
+    descShowPerformance: "在侧边栏显示TPS、TTFT、延迟等指标",
+    descShowPricing: "在侧边栏显示成本估算",
+    descShowTokenDistribution: "在侧边栏显示输入/输出/推理Token细分",
+    descShowTrend: "在侧边栏显示Token用量趋势",
+    settingsLanguage: "语言",
+    descSettingsLanguage: "切换显示语言",
+    settingsTitle: "TokenWatch设置",
+    settingsPlaceholder: "切换设置项...",
+    langAuto: "自动",
+    done: "完成",
+    closeSettings: "关闭设置",
+    menuToday: "今天",
+    menu7d: "最近 7 天",
+    menu30d: "最近 30 天",
+    menuAll: "全部时间",
+};
+const en = {
+    panelTitle: "TokenWatch",
+    collapse: "Collapse",
+    expand: "Expand",
+    sessionSummary: "Session",
+    input: "Input",
+    output: "Output",
+    cacheRead: "Cache",
+    cacheWrite: "C.Write",
+    cacheMiss: "Cache Miss",
+    hitRate: "Hit Rate",
+    requests: "Req",
+    cost: "Cost",
+    trendUp: "↑",
+    trendDown: "↓",
+    cache: "Cache",
+    performance: "Performance",
+    pricing: "Pricing",
+    tokenDistribution: "Token Distribution",
+    modelLabel: "Model",
+    provider: "Provider",
+    ttft: "TTFT",
+    tps: "TPS",
+    latency: "Latency",
+    avg: "Avg",
+    max: "Max",
+    min: "Min",
+    read: "Read",
+    write: "Write",
+    sessionAccumulated: "Session Accumulated",
+    saving: "Saving",
+    priceInput: "Input",
+    priceCacheRead: "Cache Read",
+    priceCacheWrite: "Cache Write",
+    priceOutput: "Output",
+    total: "Total",
+    system: "System",
+    user: "User",
+    agent: "Agent",
+    toolCall: "Tool Call",
+    toolResult: "Tool Result",
+    outputTokens: "Output",
+    settings: "Settings",
+    showCache: "Show Cache",
+    showPerformance: "Show Performance",
+    showPricing: "Show Pricing",
+    showTokenDistribution: "Show Token Distribution",
+    showTrend: "Show Trend",
+    language: "Language",
+    auto: "Auto",
+    cmdTitleHtml: "HTML Report",
+    cmdDescHtml: "Generate interactive HTML dashboard with token usage, cache, and performance charts",
+    cmdTitleJson: "JSON Export",
+    cmdDescJson: "Export raw usage data as JSON file",
+    cmdTitleText: "Text Report",
+    cmdDescText: "Generate plain text report file",
+    cmdTitleSettings: "Settings",
+    cmdDescSettings: "Configure sidebar display options",
+    descShowPerformance: "Display TPS, TTFT, latency metrics in sidebar",
+    descShowPricing: "Display cost estimates in sidebar",
+    descShowTokenDistribution: "Display input/output/reasoning token breakdown in sidebar",
+    descShowTrend: "Display token usage trend in sidebar",
+    settingsLanguage: "Language",
+    descSettingsLanguage: "Switch display language",
+    settingsTitle: "TokenWatch Settings",
+    settingsPlaceholder: "Toggle settings...",
+    langAuto: "Auto",
+    done: "Done",
+    closeSettings: "Close settings",
+    menuToday: "Today",
+    menu7d: "Last 7 Days",
+    menu30d: "Last 30 Days",
+    menuAll: "All Time",
+};
+let currentLang = detectLanguage();
+export function detectLanguage() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        if (locale.startsWith("zh"))
+            return "zh";
+    }
+    catch {
+        // Intl may not be available in restricted environments
+    }
+    return "en";
+}
+export function setLanguage(lang) {
+    if (lang === "auto") {
+        currentLang = detectLanguage();
+    }
+    else {
+        currentLang = lang;
+    }
+}
+export function getCurrentLanguage() {
+    return currentLang;
+}
+export function t(key) {
+    const table = currentLang === "zh" ? zh : en;
+    return table[key] ?? key;
+}

package/dist/perf-tracker.d.ts

@@ -0,0 +1,55 @@
+import type { LogEntry, SessionPerfStats } from "./formatter.js";
+interface PartEvent {
+    message_id?: string;
+    type?: string;
+    text?: string;
+    time?: {
+        start?: number;
+    };
+}
+interface MessageUpdateEvent {
+    properties: {
+        info: {
+            id?: string;
+            sessionID?: string;
+            role?: string;
+            providerID?: string;
+            modelID?: string;
+            tokens?: {
+                input?: number;
+                output?: number;
+                reasoning?: number;
+                cache?: {
+                    read?: number;
+                    write?: number;
+                };
+            };
+            cost?: number;
+            time?: {
+                created?: number;
+                completed?: number;
+            };
+        };
+    };
+}
+interface MessageRemoveEvent {
+    properties: {
+        sessionID?: string;
+        messageID?: string;
+    };
+}
+declare class PerfTracker {
+    private firstPartTimes;
+    private statsMap;
+    handlePartUpdated(event: PartEvent): void;
+    handleMessageUpdated(event: MessageUpdateEvent): void;
+    private appendLog;
+    handleMessageRemoved(event: MessageRemoveEvent): void;
+    private updateStats;
+    getSessionStats(): SessionPerfStats;
+    readLogs(last?: number): LogEntry[];
+    reset(): void;
+}
+export declare function createPerfTracker(): PerfTracker;
+export type { PartEvent, PerfTracker };
+export declare function readLogs(last?: number): LogEntry[];

package/dist/perf-tracker.js

@@ -0,0 +1,185 @@
+import { appendFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+const LOG_PATH = join(homedir(), ".opencode", "tokenwatch.jsonl");
+class PerfTracker {
+    firstPartTimes = new Map();
+    statsMap = new Map();
+    handlePartUpdated(event) {
+        if (!event.time?.start || !event.message_id)
+            return;
+        this.firstPartTimes.set(event.message_id, event.time.start);
+    }
+    handleMessageUpdated(event) {
+        const info = event.properties?.info;
+        if (!info || info.role !== "assistant")
+            return;
+        if (!info.time?.completed)
+            return;
+        const messageID = info.id ?? "";
+        const created = info.time.created;
+        const completed = info.time.completed;
+        if (!created || !completed) {
+            this.firstPartTimes.delete(messageID);
+            return;
+        }
+        const sessionID = info.sessionID ?? "";
+        const providerID = info.providerID ?? "unknown";
+        const modelID = info.modelID ?? "unknown";
+        const model = `${providerID}/${modelID}`;
+        const tokens = info.tokens;
+        const inputTokens = tokens?.input ?? 0;
+        const outputTokens = tokens?.output ?? 0;
+        const reasoningTokens = tokens?.reasoning ?? 0;
+        const cacheRead = tokens?.cache?.read ?? 0;
+        const cacheWrite = tokens?.cache?.write ?? 0;
+        const cost = info.cost ?? 0;
+        const firstPart = this.firstPartTimes.get(messageID) ?? null;
+        const latencyMs = completed - created;
+        const ttftMs = firstPart !== null ? firstPart - created : null;
+        const genMs = firstPart !== null ? completed - firstPart : null;
+        const tps = (genMs !== null && genMs > 0 && outputTokens > 0)
+            ? (outputTokens / genMs) * 1000
+            : null;
+        const tpsFallback = (tps === null && latencyMs > 0 && outputTokens > 0)
+            ? (outputTokens / latencyMs) * 1000
+            : null;
+        this.firstPartTimes.delete(messageID);
+        const entry = {
+            ts: new Date().toISOString(),
+            model,
+            providerID,
+            modelID,
+            sessionID,
+            ttft_ms: ttftMs,
+            tps: tps ?? tpsFallback,
+            latency_ms: latencyMs,
+            inputTokens,
+            outputTokens,
+            reasoningTokens,
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            cost,
+        };
+        this.appendLog(entry);
+        this.updateStats(model, entry);
+    }
+    appendLog(entry) {
+        try {
+            appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
+        }
+        catch {
+            // Silently fail — logging is non-critical
+        }
+    }
+    handleMessageRemoved(event) {
+        const mid = event.properties?.messageID ?? "";
+        if (mid) {
+            this.firstPartTimes.delete(mid);
+        }
+    }
+    updateStats(model, entry) {
+        let stats = this.statsMap.get(model);
+        if (!stats) {
+            stats = {
+                model,
+                providerID: entry.providerID,
+                requestCount: 0,
+                totalInput: 0,
+                totalOutput: 0,
+                totalCacheRead: 0,
+                totalCacheWrite: 0,
+                totalCost: 0,
+                avgTTFT: null,
+                maxTTFT: null,
+                minTTFT: null,
+                avgTPS: null,
+                maxTPS: null,
+                minTPS: null,
+                avgLatency: null,
+                maxLatency: null,
+                minLatency: null,
+            };
+            this.statsMap.set(model, stats);
+        }
+        stats.requestCount++;
+        stats.totalInput += entry.inputTokens;
+        stats.totalOutput += entry.outputTokens;
+        stats.totalCacheRead += entry.cacheReadTokens;
+        stats.totalCacheWrite += entry.cacheWriteTokens;
+        stats.totalCost += entry.cost;
+        if (entry.ttft_ms !== null) {
+            const c = stats.requestCount;
+            const prev = stats.avgTTFT;
+            stats.avgTTFT = prev !== null ? prev + (entry.ttft_ms - prev) / c : entry.ttft_ms;
+            stats.maxTTFT = stats.maxTTFT !== null ? Math.max(stats.maxTTFT, entry.ttft_ms) : entry.ttft_ms;
+            stats.minTTFT = stats.minTTFT !== null ? Math.min(stats.minTTFT, entry.ttft_ms) : entry.ttft_ms;
+        }
+        if (entry.tps !== null) {
+            const c = stats.requestCount;
+            const prev = stats.avgTPS;
+            stats.avgTPS = prev !== null ? prev + (entry.tps - prev) / c : entry.tps;
+            stats.maxTPS = stats.maxTPS !== null ? Math.max(stats.maxTPS, entry.tps) : entry.tps;
+            stats.minTPS = stats.minTPS !== null ? Math.min(stats.minTPS, entry.tps) : entry.tps;
+        }
+        if (entry.latency_ms !== null) {
+            const c = stats.requestCount;
+            const prev = stats.avgLatency;
+            stats.avgLatency = prev !== null ? prev + (entry.latency_ms - prev) / c : entry.latency_ms;
+            stats.maxLatency = stats.maxLatency !== null ? Math.max(stats.maxLatency, entry.latency_ms) : entry.latency_ms;
+            stats.minLatency = stats.minLatency !== null ? Math.min(stats.minLatency, entry.latency_ms) : entry.latency_ms;
+        }
+    }
+    getSessionStats() {
+        let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0;
+        let totalRequests = 0, totalCost = 0;
+        for (const s of this.statsMap.values()) {
+            totalInput += s.totalInput;
+            totalOutput += s.totalOutput;
+            totalCacheRead += s.totalCacheRead;
+            totalCacheWrite += s.totalCacheWrite;
+            totalRequests += s.requestCount;
+            totalCost += s.totalCost;
+        }
+        return {
+            models: Object.fromEntries(this.statsMap),
+            totals: { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalRequests, totalCost },
+        };
+    }
+    readLogs(last = 50) {
+        try {
+            if (!existsSync(LOG_PATH))
+                return [];
+            const content = readFileSync(LOG_PATH, "utf-8").trim();
+            if (!content)
+                return [];
+            const lines = content.split("\n");
+            const entries = [];
+            for (let i = Math.max(0, lines.length - last); i < lines.length; i++) {
+                try {
+                    entries.push(JSON.parse(lines[i]));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+    reset() {
+        this.firstPartTimes.clear();
+        this.statsMap.clear();
+    }
+}
+export function createPerfTracker() {
+    return new PerfTracker();
+}
+export function readLogs(last = 50) {
+    const tracker = new PerfTracker();
+    return tracker.readLogs(last);
+}

package/dist/sidebar.d.ts

@@ -0,0 +1,22 @@
+import type { TuiPluginApi, TuiTheme } from "@opencode-ai/plugin/tui";
+import type { PerfTracker } from "./perf-tracker.js";
+import type { TokenMessage } from "./tui.jsx";
+export interface SidebarConfig {
+    sidebar: {
+        showPerformance: boolean;
+        showPricing: boolean;
+        showTokenDistribution: boolean;
+        showTrend: boolean;
+    };
+    language: "zh" | "en" | "auto";
+}
+export declare function loadConfig(api: TuiPluginApi): SidebarConfig;
+interface TokenWatchPanelProps {
+    api: TuiPluginApi;
+    theme: TuiTheme;
+    perfTracker: PerfTracker;
+    messages: readonly any[];
+    allTokenMessages: TokenMessage[];
+}
+export declare function TokenWatchPanel(props: TokenWatchPanelProps): any;
+export {};