token-stats-timer 1.0.6 → 1.0.8

package/README.md

@@ -54,23 +54,13 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 
 `/notify` —— 无参查看当前状态；`on`/`off` 开启/关闭。
 
-## 每步耗时（step-timer）
-
-任务执行中实时显示每步耗时，结束后在会话里留下可回看的耗时摘要（`appendEntry` 持久化、不进入 LLM 上下文，`/resume` 后仍在）。
-
-### 实时文案
+## 任务计时（step-timer）
 
 - 任务执行中：工作指示器（spinner 文案）显示 `Working... 01:02`（整体已耗时，每秒刷新）
-- 思考阶段：隐藏思考块文案显示 `Thinking... 00:45`（当前思考块已耗时）
-
-> 说明：`Thinking...` 文案只在“隐藏思考块”模式下显示；开启思考可见时该处不显示文案，但计时不受影响。
-
-### 会话摘要
-
-- **每 turn**：每个 turn 结束后插入一条 `⏱ turn 3 · 00:45 · 思考 00:30 · bash×2 00:12 · 回复 00:03`（展开可看全部工具明细）
-- **完成**：任务结束时插入一条汇总：`✅ 任务完成 总耗时 01:23 · 思考 00:45 (54%) · 回复 00:17 · bash×3 00:21 · 6 turns`；失败/中止时标题相应变为 ❌/⏹
+- 逐条内联标注：每条 assistant 消息末尾自动追加一行 `> ⏱ 思考 00:05`——当前正在生成的消息该行实时更新，提交后永久定格；历史消息各自保留提交时的耗时、互不影响。因 pi 的 hiddenThinkingLabel 文案是全局的、无法逐条保留，故采用该内联方式（resume 回放不显示）
+- 完成后：会话末尾插入一条汇总 `总耗时 01:23`（失败时 ❌，中止时 ⏹），经 `appendEntry` 持久化、不进入 LLM 上下文，`/resume` 后仍在
 
-无独立开关，随包启用；计时口径与 run-timer 一致（一次 run = 首个 agent_start → agent_settled，含重试/压缩/排队提示）。
+无独立开关，随包启用；计时口径与 run-timer 一致（一次 run = 首个 agent_start → agent_settled，含重试/压缩/排队提示）。早期版本的每 turn 摘要（timing-turn）已移除，历史条目自动隐藏。
 
 ## 命令
 

package/package.json

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

package/step-timer.ts

@@ -1,59 +1,30 @@
-// step-timer 模块 —— 每步耗时(思考/工具/回复)+ 每 turn / 总耗时会话摘要
+// step-timer 模块 —— 任务计时
 // =============================================================================
 // 实时显示(仅交互 TUI):
-//   - 任务执行中:工作指示器文案改为 "Working... 01:02"(整体已耗时,每秒刷新)
-//   - 思考阶段:隐藏思考块文案改为 "Thinking... 00:45"(当前思考块已耗时)
-// 会话摘要(appendEntry 持久化,不进入 LLM 上下文):
-//   - 每个 turn 结束 appendEntry("timing-turn", …):该 turn 思考/工具/回复分项
-//   - agent_settled  appendEntry("timing-final", …):总耗时 + 思考占比 + 各工具统计
+//   - 任务执行中:工作指示器文案显示 "Working... 01:02"(整体已耗时,每秒刷新)
+// 逐条内联标注(每条 assistant 消息末尾自动追加一行):
+//   - 例:`ai 回复内容...` 后另起一行 `> ⏱ 思考 00:05`
+//   - 当前正在生成的消息:该行随流式内容实时更新(思考计时);消息提交后永久定格
+//   - 历史消息各自保留提交时的耗时,互不影响、不再变化(标注已存在则跳过,resume 回放不显示)
+//     (pi 的 hiddenThinkingLabel 文案是全局的、无法逐条保留,故改用内联标注)
+// 完成后汇总(appendEntry 持久化,不进入 LLM 上下文,resume 后可回看):
+//   - agent_settled  appendEntry("timing-final", …):本次任务总耗时
 //
 // 一次 run = 空闲后的首个 agent_start → agent_settled(与 run-timer 语义一致,
 // 包含重试、压缩恢复和排队的 steering/follow-up 提示)。
 
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  Theme,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 
-export type StepPhase = "idle" | "thinking" | "text" | "tool";
-
-/** 单个工具的聚合统计(当前 turn 内按工具名累计) */
-export interface ToolStat {
-  name: string;
-  count: number;
-  totalMs: number;
-  errors: number;
-}
-
-/** 一个 turn 的耗时明细(appendEntry "timing-turn") */
-export interface TurnTimingData {
-  turnIndex: number;
-  thinkingMs: number;
-  textMs: number;
-  tools: ToolStat[];
-  totalMs: number;
-}
-
 /** 一次 run 的总耗时汇总(appendEntry "timing-final") */
 export interface FinalTimingData {
   totalMs: number;
-  thinkingMs: number;
-  thinkingPct: number;
-  textMs: number;
-  tools: ToolStat[];
-  turnCount: number;
   failed: boolean;
   aborted: boolean;
 }
 
-export type { ExtensionContext };
-
-const TURN_TYPE = "timing-turn";
 const FINAL_TYPE = "timing-final";
 const TICK_MS = 1000;
-const MAX_TOOLS_SHOWN = 4;
 
 function formatDuration(ms: number): string {
   const totalSeconds = Math.max(0, Math.floor(ms / 1000));
@@ -67,33 +38,6 @@ function formatDuration(ms: number): string {
   return `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
 }
 
-function mergeToolStat(a: Map<string, ToolStat>, b: ToolStat[]): void {
-  for (const t of b) {
-    const cur = a.get(t.name) ?? { name: t.name, count: 0, totalMs: 0, errors: 0 };
-    cur.count += t.count;
-    cur.totalMs += t.totalMs;
-    cur.errors += t.errors;
-    a.set(t.name, cur);
-  }
-}
-
-function toolListText(tools: ToolStat[]): string {
-  if (tools.length === 0) return "";
-  const sorted = [...tools].sort((x, y) => y.totalMs - x.totalMs).slice(0, MAX_TOOLS_SHOWN);
-  const parts = sorted.map((t) => `${t.name}×${t.count} ${formatDuration(t.totalMs)}`);
-  if (tools.length > MAX_TOOLS_SHOWN) {
-    parts.push(`…+${tools.length - MAX_TOOLS_SHOWN}个`);
-  }
-  return parts.join(" ");
-}
-
-/** “思考 00:45 (54%)” 这类分项；为 0 时省略 */
-function segmentText(label: string, ms: number, withPct?: number): string {
-  if (ms <= 0) return "";
-  const base = `${label} ${formatDuration(ms)}`;
-  return withPct !== undefined ? `${base} (${withPct}%)` : base;
-}
-
 export function createStepTimer(pi: ExtensionAPI): void {
   let lastCtx: ExtensionContext | undefined;
   let tick: ReturnType<typeof setInterval> | undefined;
@@ -103,98 +47,33 @@ export function createStepTimer(pi: ExtensionAPI): void {
   let runFailed = false;
   let runAborted = false;
 
-  // run 级聚合(供 timing-final 用)
-  let runThinkingMs = 0;
-  let runTextMs = 0;
-  const runTools = new Map<string, ToolStat>();
-  let appendedTurns = 0;
-
-  // turn 局部状态
-  let turnIndex = 0;
-  let phase: StepPhase = "idle";
-  let phaseStartMs = 0;
-  let turnThinkingMs = 0;
-  let turnTextMs = 0;
-  const turnTools = new Map<string, ToolStat>();
-  const activeTools = new Map<string, { name: string; startMs: number }>();
-  // 自上次 turn_end 后是否有计时事件(agent_settled 时兜底结算未闭合的 turn)
-  let turnDirty = false;
+  // 逐条内联标注:当前消息的思考计时(每条 assistant 消息开始时重置)
+  // curThinkingMs:已结算的思考毫秒;thinkingStart:进行中思考块的起表时间
+  let curThinkingMs = 0;
+  let thinkingStart: number | undefined;
 
-  // ---------- 内部工具 ----------
-
-  function resetRun(): void {
-    runThinkingMs = 0;
-    runTextMs = 0;
-    runTools.clear();
-    appendedTurns = 0;
-    turnIndex = 0;
-    phase = "idle";
-    phaseStartMs = Date.now();
-    turnThinkingMs = 0;
-    turnTextMs = 0;
-    turnTools.clear();
-    activeTools.clear();
-    turnDirty = false;
-    runFailed = false;
-    runAborted = false;
-  }
-
-  /** 结算当前阶段的耗时(阶段切换 / turn 收口时调用) */
-  function closePhase(now: number, next: StepPhase): void {
-    if (phase === "thinking") {
-      turnThinkingMs += now - phaseStartMs;
-      if (lastCtx?.hasUI) lastCtx.ui.setHiddenThinkingLabel(); // 恢复默认 "Thinking..."
-    } else if (phase === "text") {
-      turnTextMs += now - phaseStartMs;
+  /** 结算当前进行中的思考块(若有) */
+  function settleThinking(now: number): void {
+    if (thinkingStart !== undefined) {
+      curThinkingMs += now - thinkingStart;
+      thinkingStart = undefined;
     }
-    // "tool" 阶段耗时按 toolCallId 单独计时(activeTools)，不走阶段时钟
-    phase = next;
-    phaseStartMs = now;
   }
 
-  function turnToolTotal(): number {
-    let sum = 0;
-    for (const t of turnTools.values()) sum += t.totalMs;
-    return sum;
+  /** 当前消息的思考总耗时(含进行中块):有思考数据才显示 */
+  function currentThinkingMs(now: number): number | undefined {
+    if (curThinkingMs === 0 && thinkingStart === undefined) return undefined;
+    return curThinkingMs + (thinkingStart !== undefined ? now - thinkingStart : 0);
   }
 
-  /** 结算并追加一条 timing-turn 条目 */
-  function finishTurn(now: number): void {
-    const tools = [...turnTools.values()];
-    const totalMs = turnThinkingMs + turnTextMs + turnToolTotal();
-    pi.appendEntry<TurnTimingData>(TURN_TYPE, {
-      turnIndex,
-      thinkingMs: turnThinkingMs,
-      textMs: turnTextMs,
-      tools,
-      totalMs,
-    });
-
-    runThinkingMs += turnThinkingMs;
-    runTextMs += turnTextMs;
-    mergeToolStat(runTools, tools);
-    appendedTurns++;
-
-    turnThinkingMs = 0;
-    turnTextMs = 0;
-    turnTools.clear();
-    turnDirty = false;
-  }
-
-  function updateLiveLabels(now: number): void {
-    if (!lastCtx?.hasUI || !runActive) return;
-    const ui = lastCtx.ui;
-    ui.setWorkingMessage(`Working... ${formatDuration(now - runStartMs)}`);
-    if (phase === "thinking") {
-      ui.setHiddenThinkingLabel(
-        `Thinking... ${formatDuration(turnThinkingMs + (now - phaseStartMs))}`,
-      );
-    }
-  }
+  const MARK_TEXT = "⏱ 思考";
 
   function startTicker(): void {
     stopTicker();
-    tick = setInterval(() => updateLiveLabels(Date.now()), TICK_MS);
+    tick = setInterval(() => {
+      if (!lastCtx?.hasUI || !runActive) return;
+      lastCtx.ui.setWorkingMessage(`Working... ${formatDuration(Date.now() - runStartMs)}`);
+    }, TICK_MS);
   }
 
   function stopTicker(): void {
@@ -203,26 +82,14 @@ export function createStepTimer(pi: ExtensionAPI): void {
     tick = undefined;
   }
 
-  function buildFinal(now: number): FinalTimingData {
-    if (phase !== "idle") closePhase(now, "idle");
-    return {
-      totalMs: now - runStartMs,
-      thinkingMs: runThinkingMs,
-      thinkingPct: Math.round((runThinkingMs / Math.max(1, now - runStartMs)) * 100),
-      textMs: runTextMs,
-      tools: [...runTools.values()],
-      turnCount: appendedTurns,
+  function appendFinal(): void {
+    pi.appendEntry<FinalTimingData>(FINAL_TYPE, {
+      totalMs: Date.now() - runStartMs,
       failed: runFailed,
       aborted: runAborted,
-    };
-  }
-
-  function appendFinal(now: number): void {
-    pi.appendEntry<FinalTimingData>(FINAL_TYPE, buildFinal(now));
+    });
   }
 
-  // ---------- 事件 ----------
-
   pi.on("session_start", (_event, ctx) => {
     lastCtx = ctx;
     stopTicker();
@@ -234,95 +101,51 @@ export function createStepTimer(pi: ExtensionAPI): void {
     if (runActive) return;
     runActive = true;
     runStartMs = Date.now();
-    resetRun();
+    runFailed = false;
+    runAborted = false;
+    curThinkingMs = 0;
+    thinkingStart = undefined;
     startTicker();
-    updateLiveLabels(runStartMs);
+    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;
-    turnDirty = true;
     const ev = event.assistantMessageEvent;
-    const now = Date.now();
     if (!ev) return;
+    const now = Date.now();
     if (ev.type === "thinking_start") {
-      if (phase !== "thinking") closePhase(now, "thinking");
-    } else if (ev.type === "text_start") {
-      if (phase !== "text") closePhase(now, "text");
+      if (thinkingStart === undefined) thinkingStart = now;
+    } else if (ev.type === "thinking_end" || ev.type === "text_start") {
+      settleThinking(now);
     }
   });
 
-  pi.on("tool_execution_start", (event, ctx) => {
+  pi.on("tool_execution_start", (_event, ctx) => {
     if (!runActive) return;
     lastCtx = ctx;
-    turnDirty = true;
-    const now = Date.now();
-    if (phase !== "tool") closePhase(now, "tool");
-    activeTools.set(event.toolCallId, { name: event.toolName, startMs: now });
-  });
-
-  pi.on("tool_execution_end", (event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-    const now = Date.now();
-    const active = activeTools.get(event.toolCallId);
-    if (!active) return;
-    activeTools.delete(event.toolCallId);
-    const ms = now - active.startMs;
-    const stat = turnTools.get(active.name) ?? {
-      name: active.name,
-      count: 0,
-      totalMs: 0,
-      errors: 0,
-    };
-    stat.count++;
-    stat.totalMs += ms;
-    if (event.isError) stat.errors++;
-    turnTools.set(active.name, stat);
-    turnDirty = true;
-    if (activeTools.size === 0) closePhase(now, "idle");
-  });
-
-  pi.on("turn_start", (event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-    turnIndex = event.turnIndex;
-  });
-
-  pi.on("turn_end", (event, ctx) => {
-    if (!runActive) return;
-    lastCtx = ctx;
-    const now = Date.now();
-    if (turnIndex !== event.turnIndex) turnIndex = event.turnIndex;
-    closePhase(now, "idle");
-    if (turnDirty) finishTurn(now);
+    // 工具执行通常在同一消息的 toolCall 内容之后:结算思考计时
+    settleThinking(Date.now());
   });
 
   pi.on("agent_end", (event, ctx) => {
     if (!runActive) return;
     lastCtx = ctx;
-    // 扫描消息找失败/中止信号(与 notify 一致,仅用于 final 摘要标记)
-    for (const msg of event.messages ?? []) {
-      if (msg.type === "assistant") {
-        if (msg.stopReason === "error" || msg.stopReason === "aborted") {
-          if (msg.stopReason === "error") runFailed = true;
-          else runAborted = true;
-        }
-        if (msg.errorMessage) runFailed = true;
-      } else if (msg.type === "toolResult" && msg.isError) {
-        runFailed = true;
-      }
-    }
   });
 
   pi.on("agent_settled", (_event, ctx) => {
     lastCtx = ctx;
     if (!runActive) return;
-    const now = Date.now();
-    closePhase(now, "idle");
-    if (turnDirty) finishTurn(now);
-    appendFinal(now);
+    appendFinal();
     if (lastCtx?.hasUI) lastCtx.ui.setWorkingMessage(); // 恢复默认 "Working..."
     runActive = false;
     stopTicker();
@@ -331,70 +154,30 @@ export function createStepTimer(pi: ExtensionAPI): void {
   pi.on("session_shutdown", (_event, _ctx) => {
     // 会话提前结束(如 /exit 或崩溃):尽力补一条最终汇总
     if (runActive) {
-      appendFinal(Date.now());
+      appendFinal();
       runActive = false;
     }
     stopTicker();
     lastCtx = undefined;
   });
 
-  // ---------- 会话摘要渲染 ----------
-
-  pi.registerEntryRenderer<TurnTimingData>(TURN_TYPE, (entry, _opts, theme) => {
-    const d = entry.data;
-    if (!d) return undefined;
-    const segs: string[] = [`turn ${d.turnIndex}`, formatDuration(d.totalMs)];
-    const thinking = segmentText("思考", d.thinkingMs);
-    if (thinking) segs.push(thinking);
-    const text = segmentText("回复", d.textMs);
-    if (text) segs.push(text);
-    const tools = toolListText(d.tools);
-    if (tools) segs.push(tools);
-
-    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-    box.addChild(new Text(theme.fg("dim", `⏱ ${segs.join(" · ")}`), 0, 0));
-    if (_opts.expanded && d.tools.length > MAX_TOOLS_SHOWN) {
-      const rest = [...d.tools]
-        .sort((x, y) => y.totalMs - x.totalMs)
-        .slice(MAX_TOOLS_SHOWN);
-      for (const t of rest) {
-        box.addChild(
-          new Text(theme.fg("dim", `  ${t.name}×${t.count} ${formatDuration(t.totalMs)}`), 0, 0),
-        );
-      }
-    }
-    return box;
+  // ---------- 逐条内联标注 ----------
+  // 只在 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) => {
     const d = entry.data;
     if (!d) return undefined;
-    const title = d.failed
-      ? theme.fg("error", "❌ 任务失败 总耗时")
-      : d.aborted
-        ? theme.fg("dim", "⏹ 任务中止 总耗时")
-        : theme.fg("accent", "✅ 任务完成 总耗时");
-    const segs: string[] = [formatDuration(d.totalMs)];
-    const thinking = segmentText("思考", d.thinkingMs, d.thinkingPct);
-    if (thinking) segs.push(thinking);
-    const text = segmentText("回复", d.textMs);
-    if (text) segs.push(text);
-    const tools = toolListText(d.tools);
-    if (tools) segs.push(tools);
-    segs.push(`${d.turnCount} turns`);
-
+    const title = theme.fg("accent", "总耗时");
     const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-    box.addChild(new Text(`${title} ${theme.fg("dim", segs.join(" · "))}`, 0, 0));
-    if (_opts.expanded && d.tools.length > MAX_TOOLS_SHOWN) {
-      const rest = [...d.tools]
-        .sort((x, y) => y.totalMs - x.totalMs)
-        .slice(MAX_TOOLS_SHOWN);
-      for (const t of rest) {
-        box.addChild(
-          new Text(theme.fg("dim", `  ${t.name}×${t.count} ${formatDuration(t.totalMs)}`), 0, 0),
-        );
-      }
-    }
+    box.addChild(new Text(`${title} ${formatDuration(d.totalMs)}`, 0, 0));
     return box;
   });
 }