token-stats-timer 1.0.8 → 1.0.10

package/README.md

@@ -1,6 +1,6 @@
 # token-stats-timer
 
-`@carlosgtrz/pi-run-timer` 与 `@liziy/token-stats` 的合并插件。
+`@liziy/token-stats` 的修改版本。
 
 一个扩展、一个 footer，同时提供 run 计时与 token 用量/配额监控。
 
@@ -23,10 +23,9 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 
 ## macOS 完成通知
 
-每次 run（agent 任务）结束后弹系统通知，区分三种结果：
+每次 run（agent 任务）结束后弹系统通知，区分两种结果：
 
 - ✅ pi 执行完成 —— 正常结束（含耗时）
-- ❌ pi 执行失败 —— 模型调用出错 / 工具执行失败（含错误摘要）
 - ⏹ pi 已中止 —— 用户 Esc 中止
 
 会话关闭时另有 👋 提示（可关）。通知经 `osascript` 发送，需在系统设置 → 通知 中允许终端 App 通知。
@@ -57,16 +56,19 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 ## 任务计时（step-timer）
 
 - 任务执行中：工作指示器（spinner 文案）显示 `Working... 01:02`（整体已耗时，每秒刷新）
-- 逐条内联标注：每条 assistant 消息末尾自动追加一行 `> ⏱ 思考 00:05`——当前正在生成的消息该行实时更新，提交后永久定格；历史消息各自保留提交时的耗时、互不影响。因 pi 的 hiddenThinkingLabel 文案是全局的、无法逐条保留，故采用该内联方式（resume 回放不显示）
-- 完成后：会话末尾插入一条汇总 `总耗时 01:23`（失败时 ❌，中止时 ⏹），经 `appendEntry` 持久化、不进入 LLM 上下文，`/resume` 后仍在
+- 完成后：会话末尾插入一条汇总，仅显示总耗时：
 
-无独立开关，随包启用；计时口径与 run-timer 一致（一次 run = 首个 agent_start → agent_settled，含重试/压缩/排队提示）。早期版本的每 turn 摘要（timing-turn）已移除，历史条目自动隐藏。
+  `总耗时 01:23`
+
+  经 `appendEntry` 持久化、不进入 LLM 上下文，`/resume` 后仍在；无主题色样式。
+
+无独立开关，随包启用；计时口径与 run-timer 一致（一次 run = 首个 agent_start → agent_settled，含重试/压缩/排队提示）。早期版本的每 turn 摘要（timing-turn）、“⏱ 思考”每条消息内联标注与 Thinking 实时标签均已移除，历史条目自动隐藏。
 
 ## 命令
 
 - `/stats` —— 无参进入套餐配置（为当前 provider 选择/关闭配额套餐）
 - `/stats day [YYYY-MM-DD]` / `hour` / `week` / `month [YYYY-MM]` —— 统计查询
-- `/stats config` —— 显示样式 / 显示内容（含「计时器」开关）/ 配额刷新时间
+- `/stats config` —— 显示样式 / 显示内容 / 配额刷新时间
 - `/notify [on|off]` —— macOS 完成通知开关（无参查看状态）
 
 ## 与两个原包的兼容性
@@ -78,7 +80,6 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 ## 安装（替换两个原包）
 
 ```bash
-pi remove npm:@carlosgtrz/pi-run-timer
 pi remove npm:@liziy/token-stats
 pi install npm:token-stats-timer
 ```

package/index.ts

@@ -18,7 +18,6 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { createRunTimer } from "./run-timer.ts";
 import { createTokenStats, formatUserPath, type SharedState } from "./token-stats.ts";
 import { createNotifier } from "./notify.ts";
 import { createStepTimer } from "./step-timer.ts";
@@ -30,7 +29,6 @@ const shared: SharedState = {
 
 export default function runTokenStatsExtension(pi: ExtensionAPI) {
   const stats = createTokenStats(pi, shared);
-  const timer = createRunTimer(pi, shared);
   // macOS 完成通知（成功/失败/中止），配置见 notify-config.json
   createNotifier(pi);
   // 每步耗时：Thinking.../Working... 实时耗时 + 每 turn/总耗时会话摘要
@@ -54,13 +52,9 @@ export default function runTokenStatsExtension(pi: ExtensionAPI) {
           // session 替换后旧 footer 可能仍被 TUI 渲染，此时 ctx 已失效，直接返回空
           if (!shared.sessionActive) return [];
 
-          // ── 上行：计时 + 指标左对齐，模型名右对齐 ──
-          // 计时器放在指标行末尾（紧邻右侧模型名）
+          // ── 上行：指标左对齐，模型名右对齐 ──
           const leftParts: string[] = [];
           leftParts.push(...stats.getMetricParts(theme, ctx));
-          if (stats.isTimerEnabled()) {
-            leftParts.push(timer.getStatusText(theme));
-          }
           const left = leftParts.join(" | ");
 
           const modelName = ctx.model?.id || "";

package/notify.ts

@@ -9,7 +9,7 @@
 //   enabled       总开关（默认 true）
 //   minDurationSec 时长低于该秒数的 run 不通知（默认 0 = 每次都通知）
 //   sound         通知声音（默认 "Glass"，"" 表示静音）
-//   onSuccess / onFailure / onAbort / onSessionEnd  各类通知开关
+//   onSuccess / onAbort / onSessionEnd  各类通知开关
 //
 // 命令：/notify on | off | status
 
@@ -27,7 +27,6 @@ export interface NotifyConfig {
   minDurationSec: number;
   sound: string;
   onSuccess: boolean;
-  onFailure: boolean;
   onAbort: boolean;
   onSessionEnd: boolean;
 }
@@ -37,7 +36,6 @@ const DEFAULT_CONFIG: NotifyConfig = {
   minDurationSec: 0,
   sound: "Glass",
   onSuccess: true,
-  onFailure: true,
   onAbort: false,
   onSessionEnd: false,
 };
@@ -80,9 +78,7 @@ export function createNotifier(pi: ExtensionAPI): void {
 
   // 当前 run 的状态（agent_start 重置，agent_end 收集，agent_settled 消费）
   let runStartMs: number | undefined;
-  let runFailed = false;
   let runAborted = false;
-  let runErrorMsg: string | undefined;
 
   // 进程内去抖计时
   let lastNotifyAt = 0;
@@ -102,9 +98,7 @@ export function createNotifier(pi: ExtensionAPI): void {
   }
 
   pi.on("agent_start", () => {
-    runFailed = false;
     runAborted = false;
-    runErrorMsg = undefined;
     if (runStartMs === undefined) runStartMs = Date.now();
   });
 
@@ -115,17 +109,7 @@ export function createNotifier(pi: ExtensionAPI): void {
       if (m.role === "assistant") {
         if (m.stopReason === "aborted") {
           runAborted = true;
-          runErrorMsg = runErrorMsg || "被用户中止";
-        } else if (m.stopReason === "error" || m.errorMessage) {
-          runFailed = true;
-          runErrorMsg = runErrorMsg || m.errorMessage || "模型调用出错";
         }
-      } else if (m.role === "toolResult" && m.isError) {
-        runFailed = true;
-        const toolMsg = `工具 ${m.toolName} 执行失败`;
-        runErrorMsg = runErrorMsg && !runErrorMsg.startsWith("工具 ")
-          ? runErrorMsg
-          : toolMsg;
       }
     }
   });
@@ -142,19 +126,11 @@ export function createNotifier(pi: ExtensionAPI): void {
 
     const dur = startMs !== undefined ? `${formatDuration(durationMs)}` : "-";
 
-    if (runFailed) {
-      if (config.onFailure) {
-        notify(
-          "❌ pi 执行失败",
-          `耗时：${dur}\n${truncate(runErrorMsg || "未知错误")}`,
-          config.sound,
-        );
-      }
-    } else if (runAborted) {
+    if (runAborted) {
       if (config.onAbort) {
         notify(
           "⏹ pi 已中止",
-          `耗时：${dur}\n${truncate(runErrorMsg || "执行被中止")}`,
+          `耗时：${dur}\n${truncate("执行被中止")}`,
           config.sound,
         );
       }
@@ -167,9 +143,7 @@ export function createNotifier(pi: ExtensionAPI): void {
     }
 
     // 消费本次结果，避免串扰下一次 run
-    runFailed = false;
     runAborted = false;
-    runErrorMsg = undefined;
   });
 
   // 会话关闭时提示（可选）
@@ -196,7 +170,7 @@ export function createNotifier(pi: ExtensionAPI): void {
         const sound = config.sound ? `, 声音=${config.sound}` : ", 静音";
         ctx.ui.notify(
           `完成通知: ${config.enabled ? "开" : "关"}, 最短时长=${config.minDurationSec}s, ` +
-            `成功=${config.onSuccess ? "开" : "关"}, 失败=${config.onFailure ? "开" : "关"}, ` +
+            `成功=${config.onSuccess ? "开" : "关"}, ` +
             `中止=${config.onAbort ? "开" : "关"}, 会话结束=${config.onSessionEnd ? "开" : "关"}${sound}`,
           "info",
         );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-stats-timer",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "pi extension to display token usage and time spend.",
   "keywords": [
     "pi-package",

package/step-timer.ts

@@ -2,13 +2,8 @@
 // =============================================================================
 // 实时显示(仅交互 TUI):
 //   - 任务执行中:工作指示器文案显示 "Working... 01:02"(整体已耗时,每秒刷新)
-// 逐条内联标注(每条 assistant 消息末尾自动追加一行):
-//   - 例:`ai 回复内容...` 后另起一行 `> ⏱ 思考 00:05`
-//   - 当前正在生成的消息:该行随流式内容实时更新(思考计时);消息提交后永久定格
-//   - 历史消息各自保留提交时的耗时,互不影响、不再变化(标注已存在则跳过,resume 回放不显示)
-//     (pi 的 hiddenThinkingLabel 文案是全局的、无法逐条保留,故改用内联标注)
 // 完成后汇总(appendEntry 持久化,不进入 LLM 上下文,resume 后可回看):
-//   - agent_settled  appendEntry("timing-final", …):本次任务总耗时
+//   - agent_settled  appendEntry("timing-final", …):仅本次任务总耗时
 //
 // 一次 run = 空闲后的首个 agent_start → agent_settled(与 run-timer 语义一致,
 // 包含重试、压缩恢复和排队的 steering/follow-up 提示)。
@@ -19,8 +14,6 @@ import { Box, Text } from "@earendil-works/pi-tui";
 /** 一次 run 的总耗时汇总(appendEntry "timing-final") */
 export interface FinalTimingData {
   totalMs: number;
-  failed: boolean;
-  aborted: boolean;
 }
 
 const FINAL_TYPE = "timing-final";
@@ -44,29 +37,6 @@ export function createStepTimer(pi: ExtensionAPI): void {
 
   let runActive = false;
   let runStartMs = 0;
-  let runFailed = false;
-  let runAborted = false;
-
-  // 逐条内联标注:当前消息的思考计时(每条 assistant 消息开始时重置)
-  // curThinkingMs:已结算的思考毫秒;thinkingStart:进行中思考块的起表时间
-  let curThinkingMs = 0;
-  let thinkingStart: number | undefined;
-
-  /** 结算当前进行中的思考块(若有) */
-  function settleThinking(now: number): void {
-    if (thinkingStart !== undefined) {
-      curThinkingMs += now - thinkingStart;
-      thinkingStart = undefined;
-    }
-  }
-
-  /** 当前消息的思考总耗时(含进行中块):有思考数据才显示 */
-  function currentThinkingMs(now: number): number | undefined {
-    if (curThinkingMs === 0 && thinkingStart === undefined) return undefined;
-    return curThinkingMs + (thinkingStart !== undefined ? now - thinkingStart : 0);
-  }
-
-  const MARK_TEXT = "⏱ 思考";
 
   function startTicker(): void {
     stopTicker();
@@ -85,8 +55,6 @@ export function createStepTimer(pi: ExtensionAPI): void {
   function appendFinal(): void {
     pi.appendEntry<FinalTimingData>(FINAL_TYPE, {
       totalMs: Date.now() - runStartMs,
-      failed: runFailed,
-      aborted: runAborted,
     });
   }
 
@@ -101,47 +69,10 @@ export function createStepTimer(pi: ExtensionAPI): void {
     if (runActive) return;
     runActive = true;
     runStartMs = Date.now();
-    runFailed = false;
-    runAborted = false;
-    curThinkingMs = 0;
-    thinkingStart = undefined;
     startTicker();
     if (lastCtx?.hasUI) lastCtx.ui.setWorkingMessage("Working... 00:00");
   });
 
-  // 每条 assistant 消息开始时重置思考计时
-  pi.on("message_start", (event, ctx) => {
-    if (!runActive || event.message.role !== "assistant") return;
-    lastCtx = ctx;
-    curThinkingMs = 0;
-    thinkingStart = undefined;
-  });
-
-  pi.on("message_update", (event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-    const ev = event.assistantMessageEvent;
-    if (!ev) return;
-    const now = Date.now();
-    if (ev.type === "thinking_start") {
-      if (thinkingStart === undefined) thinkingStart = now;
-    } else if (ev.type === "thinking_end" || ev.type === "text_start") {
-      settleThinking(now);
-    }
-  });
-
-  pi.on("tool_execution_start", (_event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-    // 工具执行通常在同一消息的 toolCall 内容之后:结算思考计时
-    settleThinking(Date.now());
-  });
-
-  pi.on("agent_end", (event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-  });
-
   pi.on("agent_settled", (_event, ctx) => {
     lastCtx = ctx;
     if (!runActive) return;
@@ -161,23 +92,11 @@ export function createStepTimer(pi: ExtensionAPI): void {
     lastCtx = undefined;
   });
 
-  // ---------- 逐条内联标注 ----------
-  // 只在 assistant 文本上追加一行耗时;已带标注(历史消息重渲染)则跳过保持原值
-  pi.registerMarkdownTransformer((markdown, context) => {
-    if (context.messageType !== "assistant") return markdown;
-    if (markdown.includes(MARK_TEXT)) return markdown;
-    const now = Date.now();
-    const ms = currentThinkingMs(now);
-    if (ms === undefined) return markdown;
-    return `${markdown}\n\n> ${MARK_TEXT} ${formatDuration(ms)}`;
-  });
-
-  pi.registerEntryRenderer<FinalTimingData>(FINAL_TYPE, (entry, _opts, theme) => {
+  pi.registerEntryRenderer<FinalTimingData>(FINAL_TYPE, (entry, _opts, _theme) => {
     const d = entry.data;
     if (!d) return undefined;
-    const title = theme.fg("accent", "总耗时");
-    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-    box.addChild(new Text(`${title} ${formatDuration(d.totalMs)}`, 0, 0));
+    const box = new Box(1, 1);
+    box.addChild(new Text(`总耗时 ${formatDuration(d.totalMs)}`, 0, 0));
     return box;
   });
 }

package/token-stats.ts

@@ -138,7 +138,6 @@ export type DisplayKey =
   | "quota5h"     // 5h 额度
   | "quotaWeek"   // 周额度
   | "quotaClock"  // 刷新时间（⏱）
-  | "timer";      // run 计时（⏱ run/prev/max）
 
 export interface DisplayConfig {
   items: Record<DisplayKey, boolean>;
@@ -465,7 +464,6 @@ const DEFAULT_DISPLAY_CONFIG: DisplayConfig = {
     quota5h: true,
     quotaWeek: true,
     quotaClock: true,
-    timer: true,
   },
   contextStyle: "pct-window",
   speedStyle: "t/s",
@@ -476,8 +474,6 @@ const DEFAULT_DISPLAY_CONFIG: DisplayConfig = {
 export interface TokenStatsHandle {
   /** footer 上行指标段（不含 run 计时；计时由 index.ts 拼接） */
   getMetricParts(theme: Theme, ctx: ExtensionContext): string[];
-  /** 是否显示 run 计时段 */
-  isTimerEnabled(): boolean;
 }
 
 export function createTokenStats(
@@ -1750,10 +1746,10 @@ export function createTokenStats(
         } else if (subChoice === "显示内容") {
           const itemLabels: DisplayKey[] = [
             "input", "output", "totalTokens", "cacheHit", "speed", "context",
-            "quota5h", "quotaWeek", "quotaClock", "timer",
+            "quota5h", "quotaWeek", "quotaClock",
           ];
           const itemNames: Record<DisplayKey, string> = {
-            timer: "计时器", input: "输入", output: "输出", totalTokens: "总token",
+            input: "输入", output: "输出", totalTokens: "总token",
             cacheHit: "缓存命中", speed: "速度", context: "容量",
             quota5h: "5h额度", quotaWeek: "周额度", quotaClock: "刷新时间",
           };
@@ -1843,6 +1839,5 @@ export function createTokenStats(
 
   return {
     getMetricParts,
-    isTimerEnabled: () => displayConfig.items.timer === true,
   };
 }

package/run-timer.ts

@@ -1,181 +0,0 @@
-// run-token-stats / run-timer 模块
-// =============================================================================
-// 由 @carlosgtrz/pi-run-timer 0.2.0 移植而来，与 @liziy/token-stats 合并为一个插件。
-// 原实现通过 ctx.ui.setStatus 注入 footer；合并后改为提供 getStatusText()，
-// 由 index.ts 把计时文本拼进统一 footer 的指标行。
-//
-// 显示：当前 run 已耗时 / 上一次 run 耗时 / 会话分支内最长 run 耗时（带 prompt 预览）
-// 一次 run = 从空闲后的第一个 agent_start 到 agent_settled 的连续忙碌期，
-// 包含重试、压缩恢复以及排队的 steering/follow-up 提示。
-//
-// 状态通过 pi.appendEntry 持久化到 session，/reload 后自动恢复。
-
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  Theme,
-} from "@earendil-works/pi-coding-agent";
-import type { SharedState } from "./token-stats.ts";
-
-const STATE_TYPE = "run-timer-state";
-const LEGACY_STATE_TYPE = "turn-timer-state";
-
-type TimerState = {
-  currentRunStartMs?: number;
-  previousRunDurationMs?: number;
-  longestRunDurationMs?: number;
-};
-
-function formatDuration(ms: number): string {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  if (hours > 0) {
-    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
-  }
-  return `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
-}
-
-function isTimerState(value: unknown): value is TimerState {
-  if (!value || typeof value !== "object") return false;
-  const state = value as TimerState;
-  return (
-    (state.currentRunStartMs === undefined || typeof state.currentRunStartMs === "number") &&
-    (state.previousRunDurationMs === undefined || typeof state.previousRunDurationMs === "number") &&
-    (state.longestRunDurationMs === undefined || typeof state.longestRunDurationMs === "number")
-  );
-}
-
-export interface RunTimerHandle {
-  /** 计时段文本，例如 "● run 01:23 · prev 00:40 · max 03:12 (Review README…)" */
-  getStatusText(theme: Theme): string;
-}
-
-export function createRunTimer(
-  pi: ExtensionAPI,
-  shared: SharedState,
-): RunTimerHandle {
-  let timer: ReturnType<typeof setInterval> | undefined;
-
-  let currentRunStartMs: number | undefined;
-  let previousRunDurationMs: number | undefined;
-  let longestRunDurationMs: number | undefined;
-
-  let lastCtx: ExtensionContext | undefined;
-
-  function getState(): TimerState {
-    return {
-      currentRunStartMs,
-      previousRunDurationMs,
-      longestRunDurationMs,
-    };
-  }
-
-  function applyState(state: TimerState): void {
-    currentRunStartMs = state.currentRunStartMs;
-    previousRunDurationMs = state.previousRunDurationMs;
-    longestRunDurationMs = state.longestRunDurationMs;
-  }
-
-  function saveState(): void {
-    pi.appendEntry(STATE_TYPE, getState());
-  }
-
-  function restoreState(ctx: ExtensionContext): void {
-    for (const entry of [...ctx.sessionManager.getBranch()].reverse()) {
-      if (entry.type !== "custom") continue;
-      if (entry.customType !== STATE_TYPE && entry.customType !== LEGACY_STATE_TYPE) continue;
-      if (isTimerState(entry.data)) {
-        applyState(entry.data);
-      }
-      return;
-    }
-  }
-
-  function stopTimer(): void {
-    if (!timer) return;
-    clearInterval(timer);
-    timer = undefined;
-  }
-
-  function startTimer(): void {
-    stopTimer();
-    // 运行期间每秒刷一次 footer，让计时文本跳动
-    timer = setInterval(() => {
-      if (!lastCtx?.hasUI) return;
-      shared.requestRender?.();
-    }, 1000);
-  }
-
-  pi.on("session_start", (_event, ctx) => {
-    lastCtx = ctx;
-    stopTimer();
-    restoreState(ctx);
-    if (!ctx.hasUI) return;
-    if (currentRunStartMs !== undefined) startTimer();
-    shared.requestRender?.();
-  });
-
-  pi.on("agent_start", (_event, ctx) => {
-    lastCtx = ctx;
-    if (!ctx.hasUI) return;
-
-    if (currentRunStartMs === undefined) {
-      currentRunStartMs = Date.now();
-      startTimer();
-    }
-
-    shared.requestRender?.();
-  });
-
-  pi.on("agent_settled", (_event, ctx) => {
-    lastCtx = ctx;
-    if (!ctx.hasUI) {
-      stopTimer();
-      return;
-    }
-    if (currentRunStartMs === undefined) {
-      shared.requestRender?.();
-      return;
-    }
-
-    const duration = Date.now() - currentRunStartMs;
-    previousRunDurationMs = duration;
-
-    if (longestRunDurationMs === undefined || duration > longestRunDurationMs) {
-      longestRunDurationMs = duration;
-    }
-
-    currentRunStartMs = undefined;
-    stopTimer();
-    saveState();
-    shared.requestRender?.();
-  });
-
-  pi.on("session_shutdown", (_event, _ctx) => {
-    // 保存计时状态（persist 到 session），停掉 tick 定时器
-    saveState();
-    stopTimer();
-    lastCtx = undefined;
-  });
-
-  return {
-    getStatusText(theme: Theme): string {
-      const startMs = currentRunStartMs;
-      const working = startMs !== undefined;
-
-      const elapsed = startMs !== undefined ? formatDuration(Date.now() - startMs) : "idle";
-      const prev = previousRunDurationMs !== undefined ? formatDuration(previousRunDurationMs) : "--:--";
-      const max = longestRunDurationMs !== undefined ? formatDuration(longestRunDurationMs) : "--:--";
-
-      const indicator = working ? theme.fg("accent", "●") : theme.fg("dim", "○");
-      const elapsedText = working ? theme.fg("text", elapsed) : theme.fg("dim", elapsed);
-      const label = theme.fg("dim", " run ");
-      const stats = theme.fg("dim", ` · prev ${prev} · max ${max}`);
-
-      return `${indicator}${label}${elapsedText}${stats}`;
-    },
-  };
-}