token-stats-timer 1.0.18 → 1.1.1

package/README.md

@@ -20,6 +20,31 @@ Footer 上行（左对齐）：
 
 Footer 下行：cwd + git 分支 + 其他扩展状态。
 
+## 按模型自动记忆思考强度（thinking-memory）
+
+不用命令手动设置，**手动切换思考强度时自动记录**为当前模型的默认级别，
+会话启动 / 切换模型时自动恢复。参考 `@tifan/pi-preferred-thinking` 的按模型偏好机制，
+改为以实际切换行为作为记忆来源（默认开启）：
+
+- 手动切换 thinking level（快捷键 / /thinking / 设置界面）→ 自动记录到当前模型
+- `session_start` / `model_select` → 自动应用该模型记忆的级别
+- 自身 `setThinkingLevel` 与模型切换引发的级别变化（如不支持 max 被 clamp）不会误记录
+
+- `/auto-remember-thinking-level` —— 无参查看状态；`on` / `off` 启用或禁用（默认开启）
+
+配置：`~/.pi/agent/extensions/token-stats/auto-remember-thinking-level.json`
+
+```json
+{
+  "enabled": true,
+  "levels": {
+    "opencode-go/deepseek-v4-flash": "max"
+  }
+}
+```
+
+> 若同时安装原 `@tifan/pi-preferred-thinking`，其 session_start 自动应用会与本功能互相覆盖，建议二选一。
+
 ## macOS 完成通知
 
 每次 run（agent 任务）结束后弹系统通知，区分两种结果：
@@ -81,6 +106,7 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 - `/stats limit` —— 套餐配置（为当前 provider 选择/关闭配额套餐；选 GLM 后会继续询问是否配置团队套餐凭证）
 - `/stats config` —— 显示样式 / 显示内容 / 配额刷新时间 / GLM 团队凭证
 - `/notify [on|off|test]` —— 通知开关 / 测试（无参查看状态）
+- `/auto-remember-thinking-level [on|off]` —— 自动记忆思考强度开关（无参查看状态）
 
 ## GLM 团队套餐（Team Plan）
 
@@ -88,7 +114,7 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 
 本插件在**组织 ID 与项目 ID 都配置**时才走团队查询，否则回退个人版查询：
 
-- 启用 GLM 套餐后（`/stats` 选 GLM）会自动弹出团队凭证配置询问，可「✏️ 配置/修改」或「跳过」
+- 启用 GLM 套餐后（`/stats limit` 选 GLM）会自动弹出团队凭证配置询问，可「✏️ 配置/修改」或「跳过」
 - 随时可通过 `/stats config` → 「GLM 团队凭证」修改或清除
 - 凭证保存在 `~/.pi/agent/extensions/token-stats/config.json` 的 `teamCredential` 字段：
 

package/index.ts

@@ -10,6 +10,9 @@
 // 模块划分：
 //   run-timer.ts   —— run 计时状态机 + session 持久化（原 pi-run-timer）
 //   token-stats.ts —— token 统计 + 套餐配额 + JSONL 日志 + /stats（原 token-stats）
+//   notify.ts      —— macOS 完成通知（成功/失败/中止）
+//   step-timer.ts  —— 任务计时（Working 实时耗时 + 总耗时汇总）
+//   thinking-memory.ts —— 按模型自动记忆思考强度（手动切换时记录，默认开启）
 //
 // 与两个原包的兼容性：
 //   - 配置沿用 ~/.pi/agent/extensions/token-stats/{config.json,display-config.json}
@@ -21,6 +24,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { createTokenStats, formatUserPath, type SharedState } from "./token-stats.ts";
 import { createNotifier } from "./notify.ts";
 import { createStepTimer } from "./step-timer.ts";
+import { createThinkingMemory } from "./thinking-memory.ts";
 
 const shared: SharedState = {
   sessionActive: false,
@@ -33,6 +37,8 @@ export default function runTokenStatsExtension(pi: ExtensionAPI) {
   createNotifier(pi);
   // 每步耗时：Thinking.../Working... 实时耗时 + 每 turn/总耗时会话摘要
   createStepTimer(pi);
+  // 按模型自动记忆思考强度（/auto-remember-thinking-level），默认开启
+  createThinkingMemory(pi);
 
   pi.on("session_start", (_event, ctx) => {
     shared.sessionActive = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-stats-timer",
-  "version": "1.0.18",
+  "version": "1.1.1",
   "description": "pi extension to display token usage and time spend.",
   "keywords": [
     "pi-package",
@@ -16,6 +16,7 @@
     "token-stats.ts",
     "notify.ts",
     "step-timer.ts",
+    "thinking-memory.ts",
     "README.md"
   ],
   "scripts": {

package/thinking-memory.ts

@@ -0,0 +1,141 @@
+// thinking-memory 模块 —— 按模型自动记忆思考强度
+// =============================================================================
+// 行为（默认开启，/auto-remember-thinking-level on|off 切换）：
+//   - 用户手动切换 thinking level 时，自动记录为当前模型的默认级别
+//   - session_start / model_select 时自动应用该模型记忆的级别
+//   - 扩展自身 setThinkingLevel 与模型切换引起的级别变化不会被误记录
+//
+// 配置：~/.pi/agent/extensions/token-stats/auto-remember-thinking-level.json
+//   {
+//     "enabled": true,
+//     "levels": { "opencode-go/deepseek-v4-flash": "max" }
+//   }
+//
+// 参考 @tifan/pi-preferred-thinking（手动设置命令）改为自动记忆模式：不提供
+// 单独设置命令，以用户的实际切换行为作为记忆来源。
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
+
+const CONFIG_DIR = join(homedir(), ".pi/agent/extensions/token-stats");
+const CONFIG_FILE = join(CONFIG_DIR, "auto-remember-thinking-level.json");
+
+const VALID_LEVELS = new Set<ThinkingLevel>([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+
+interface ThinkingMemoryConfig {
+  enabled: boolean;
+  levels: Record<string, ThinkingLevel>;
+}
+
+const DEFAULT_CONFIG: ThinkingMemoryConfig = { enabled: true, levels: {} };
+
+/** 判定「手动切换」的窗口：距模型切换多少毫秒内的级别变化视为切换引起 */
+const MODEL_SWITCH_WINDOW_MS = 200;
+/** 自身 apply 引起的级别变化要在多少毫秒内匹配上才算（防止残留标志误吞手动切换） */
+const APPLY_WINDOW_MS = 100;
+
+function loadConfig(): ThinkingMemoryConfig {
+  try {
+    if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG, levels: {} };
+    const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) as unknown;
+    const cfg = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+    const levels: Record<string, ThinkingLevel> = {};
+    const configured = cfg.levels;
+    if (configured && typeof configured === "object" && !Array.isArray(configured)) {
+      for (const [modelKey, level] of Object.entries(configured)) {
+        if (typeof level === "string" && VALID_LEVELS.has(level as ThinkingLevel)) {
+          levels[modelKey] = level as ThinkingLevel;
+        }
+      }
+    }
+    return { enabled: cfg.enabled !== false, levels };
+  } catch {
+    return { ...DEFAULT_CONFIG, levels: {} };
+  }
+}
+
+function saveConfig(cfg: ThinkingMemoryConfig): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}
+
+export function createThinkingMemory(pi: ExtensionAPI): void {
+  let cfg = loadConfig();
+
+  // 自身 apply 的记录：apply 时间 + 目标级别，事件匹配且窗口内则视为自身引起
+  let lastApply: { at: number; level: ThinkingLevel } | null = null;
+  // 最近一次模型切换时间戳（判断级别变化是否由切模型/clamp 引起）
+  let lastModelSwitchAt = 0;
+
+  /** 应用当前模型的记忆级别（自身 setThinkingLevel 不会触发误记录） */
+  function applyForModel(ctx: ExtensionContext): void {
+    if (!cfg.enabled) return;
+    if (!ctx.model) return;
+    const modelKey = `${ctx.model.provider}/${ctx.model.id}`;
+    const level = cfg.levels[modelKey];
+    if (!level) return;
+    if (pi.getThinkingLevel() === level) return;
+
+    lastApply = { at: Date.now(), level };
+    pi.setThinkingLevel(level);
+  }
+
+  pi.registerCommand("auto-remember-thinking-level", {
+    description: "自动记忆思考强度: on | off（无参查看状态）",
+    handler: (args, ctx) => {
+      const arg = args.trim();
+      if (arg === "on" || arg === "off") {
+        cfg = { ...cfg, enabled: arg === "on" };
+        saveConfig(cfg);
+        ctx.ui.notify(`自动记忆思考强度已${arg === "on" ? "开启" : "关闭"}`, "info");
+      } else {
+        ctx.ui.notify(`自动记忆思考强度: ${cfg.enabled ? "开" : "关"}`, "info");
+      }
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    applyForModel(ctx);
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    lastModelSwitchAt = Date.now();
+    applyForModel(ctx);
+  });
+
+  pi.on("thinking_level_select", (event, ctx) => {
+    if (!cfg.enabled) return;
+    if (!ctx.model) return;
+    const level = event.level as ThinkingLevel;
+    if (!VALID_LEVELS.has(level)) return;
+
+    // 自身 apply（session_start / model_select 恢复记忆）引起的变化：忽略
+    if (lastApply && Date.now() - lastApply.at < APPLY_WINDOW_MS && level === lastApply.level) {
+      lastApply = null;
+      return;
+    }
+
+    const modelKey = `${ctx.model.provider}/${ctx.model.id}`;
+    // 模型切换时 level 变化先于 model_select 发出，故延迟确认：
+    // 窗口内 lastModelSwitchAt 发生变化（发生了模型切换）则丢弃，防止误记录
+    const switchedAtSnapshot = lastModelSwitchAt;
+    setTimeout(() => {
+      if (lastModelSwitchAt !== switchedAtSnapshot) return;
+      if (cfg.levels[modelKey] === level) return;
+      cfg = { ...cfg, levels: { ...cfg.levels, [modelKey]: level } };
+      saveConfig(cfg);
+    }, MODEL_SWITCH_WINDOW_MS);
+  });
+}