pi-thinking-header 0.3.4 → 0.4.0

package/README.md

@@ -42,17 +42,26 @@ pi install ./pi-thinking-header
 所有功能的统一入口：
 
 ```
-/thinking-header                  # 状态总览（模式/补丁状态/decimals）+ 用法
+/thinking-header                  # 状态总览（模式/补丁状态/autoPatch/decimals）+ 用法
 /thinking-header patch           # 应用/修复完整模式补丁（确认后执行）
+/thinking-header autopatch       # 查看启动自动补丁状态
+/thinking-header autopatch on|off# 启动时自动检查并应用/迁移补丁（默认 on）
 /thinking-header decimals        # 查看当前小数位
 /thinking-header decimals <0-6>  # 设置小数位并持久化（默认 2）
 ```
 
+启动自动补丁（`autopatch`，默认开启）：每次会话启动（`session_start`）自动探测磁盘上的
+bundle——未打补丁时自动应用、检测到旧版本 patch 时自动迁移（installer 自带备份恢复逻辑），
+已是最新的则静默跳过。补丁写入磁盘后需重启 pi 才生效：当前会话仍用降级/旧渲染，notify
+会提示。因此 `pi update` 之后补丁丢失、或插件包更新带来新 patch 版本时，都无需手动
+处理，下次启动自动修复。关闭方式：`/thinking-header autopatch off`，或直接编辑配置文件
+（`{"autoPatch": false}`）。
+
 补丁安装（`patch` 子命令，内部运行 `node install-patch.mjs`）：
 
-- 已打补丁 → 提示 already applied（含当前 decimals）
-- 未打补丁（或补丁版本较旧）→ 确认后执行安装/迁移，输出结果并提醒重启 pi（当前会话仍是旧代码，重启后生效）
-- `pi update` 之后补丁丢失时，extension 自动进入降级模式，此时用该命令可一键修复
+- 已是当前版本 → 提示 already applied（含当前 decimals）
+- 未打补丁（或补丁版本较旧 → 迁移）→ 确认后执行安装/迁移，输出结果并提醒重启 pi（当前会话仍是旧代码，重启后生效）
+- `pi update` 之后补丁丢失时，extension 自动进入降级模式；启动自动补丁（默认开）会在下次会话开始时自动修复，也可用该命令立即修复
 
 小数位配置（`decimals` 子命令）：
 
@@ -67,7 +76,8 @@ pi install ./pi-thinking-header
 
 pi 的 extension API 无法接管内置 thinking 块的折叠渲染，完整效果需要附带
 的 bundle patch。推荐直接在 pi 会话内运行 `/thinking-header patch`
-（自动定位安装位置）；也可手动执行：
+（自动定位安装位置）；也可什么都不做——默认开启的启动自动补丁会在首次
+会话开始时自动应用。手动执行：
 
 ```bash
 # npm 安装：~/.pi/agent/npm/pi-thinking-header/install-patch.mjs
@@ -84,8 +94,9 @@ node <包目录>/install-patch.mjs
 - 小数点位数渲染时实时读取配置文件（mtime 缓存），与降级模式共享同一份配置
 - 幂等；自动从 v1/v2/v3/v3.1/v3.2 patch 迁移（恢复原始备份后重新应用；早期 v3
   折叠组件缺 `invalidate()`、退出/切换模式时触发 `this.child.invalidate is not
-  a function` 崩溃且无备份时，会先原地热修复）；`pi update` 后重跑一次即可；
-  插件包更新后也建议重跑 `/thinking-header patch` 使 patch 与 extension 版本一致
+  a function` 崩溃且无备份时，会先原地热修复）；`pi update` 后无需手动处理——
+  启动自动补丁（默认开）会在下次会话开始时重新应用/迁移；插件包更新后同样如此
+  （patch 版本随插件更新时自动迁移到新版）
 - 回滚：
   ```bash
   cp <chunk路径>.pre-thinking-header.bak <chunk路径>
@@ -95,8 +106,9 @@ node <包目录>/install-patch.mjs
 ### 纯插件模式：extension 自动降级
 
 extension 启动时探测运行中的 pi bundle：**检测到任意版本的 patch 时**（含旧版本）
-extension 保持惰性（避免双标题），请运行 `/thinking-header patch` 迁移到当前 patch 版本；
-**未检测到 patch 时**自动进入降级模式：
+extension 保持惰性（避免双标题；旧版本会在下次会话启动时被自动迁移到当前版本，
+或运行 `/thinking-header patch` 立即迁移）；**未检测到 patch 时**自动进入降级模式，
+并在会话启动时自动应用补丁（默认行为，可关闭）：
 
 - 展开的 thinking：通过 markdown transformer 前置 `Thinking (~N tokens)` 标题行
   （按块正确计数，`pi update` 后依然有效，无需维护）。流式期间同样保持稳定

package/index.js

@@ -36,6 +36,14 @@
  *      older transcript messages will show the most recent label. Run
  *      /thinking-header patch for per-message fidelity.
  *
+ * Startup auto-patch (autoPatch, default on): every session_start re-probes
+ * the bundle — unpatched → apply the patch, older family version → migrate —
+ * so a lost patch after `pi update` (or a newer extension release) heals on
+ * the next launch with zero manual steps. The patched file matters for the
+ * NEXT restart; the running session keeps its fallback (or old-patch)
+ * renderer and a notify explains that. Disable: /thinking-header autopatch
+ * off, or {"autoPatch": false} in the config file.
+ *
  * Token counts are local estimates: ceil(chars / 4). The k-token decimal places
  * are configurable (default 2): /thinking-header decimals <0-6>, persisted to
  * <agentDir>/thinking-header.json ({"decimals": 2}). Both modes re-read the
@@ -56,9 +64,16 @@ const INSTALLER_PATH = fileURLToPath(new URL("./install-patch.mjs", import.meta.
 
 // Family-wide marker: ANY patch version owns header rendering end-to-end, so
 // the extension must stay inert for all of them (avoids double headers). The
-// /thinking-header patch migrates older patch versions to the current one.
+// /thinking-header patch (and the startup auto-patch) migrates older patch
+// versions to the current one.
 const MARKER = "pi-thinking-header";
 
+// Current patch version — keep in sync with CURRENT_MARKER in
+// install-patch.mjs. A disk bundle carrying only an older family version is
+// "patched" (extension stays inert) but not "current" (auto-migrates).
+const PATCH_VERSION = "v3.3";
+const CURRENT_MARKER = MARKER + ":" + PATCH_VERSION;
+
 // ---------------- decimals config (shared with the bundle patch) -------------
 // <agentDir>/thinking-header.json: { "decimals": 2 } — k-token decimal places.
 // The bundle patch reads the same file at render time (mtime-cached), so both
@@ -100,7 +115,10 @@ const getDecimals = () => {
   return typeof d === "number" && Number.isInteger(d) && d >= 0 && d <= 6 ? d : DEFAULT_DECIMALS;
 };
 
-function saveDecimals(n) {
+// Startup auto-patch: only an explicit `false` disables it (absent key = on).
+const getAutoPatch = () => loadConfig().autoPatch !== false;
+
+function saveConfigKey(key, value) {
   let cfg = {};
   try {
     const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
@@ -108,7 +126,7 @@ function saveDecimals(n) {
   } catch {
     // no/invalid config → start fresh, keep nothing
   }
-  cfg.decimals = n;
+  cfg[key] = value;
   mkdirSync(dirname(CONFIG_PATH), { recursive: true });
   writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
   configCache.mtime = -1n; // force re-read on next loadConfig()
@@ -119,7 +137,9 @@ const COMPONENT_ANCHOR =
 
 /**
  * Locate the running pi's bundle chunk that contains AssistantMessageComponent.
- * Returns { found: true, patched: boolean } or { found: false }.
+ * Returns { found: true, patched, current } or { found: false }:
+ *  - patched: ANY pi-thinking-header family version is on disk
+ *  - current: exactly the version this extension ships (PATCH_VERSION)
  */
 function probeBundle() {
   try {
@@ -134,7 +154,11 @@ function probeBundle() {
       const path = join(chunksDir, file);
       const src = readFileSync(path, "utf8");
       if (!src.includes(COMPONENT_ANCHOR)) continue;
-      return { found: true, patched: src.includes(MARKER) };
+      return {
+        found: true,
+        patched: src.includes(MARKER),
+        current: src.includes(CURRENT_MARKER),
+      };
     }
   } catch {
     // pi binary not resolvable — fall through
@@ -210,10 +234,58 @@ const thinkingLabel = (blocks, running) => {
   return label;
 };
 
+/**
+ * Startup auto-patch: on session_start, re-probe the bundle and run the
+ * installer when the disk is unpatched (apply) or carries an older family
+ * version (migrate). The patched file only matters for the NEXT pi start —
+ * the running session keeps whichever renderer it booted with — so the
+ * notify says so. Best-effort by design: failures degrade to the manual
+ * /thinking-header patch command, never to a broken startup.
+ */
+function registerAutoPatch(pi) {
+  pi.on("session_start", async (_event, ctx) => {
+    try {
+      if (!getAutoPatch()) return;
+      const before = probeBundle();
+      if (!before.found || before.current) return; // up to date / not resolvable
+      const migrating = before.patched; // older family version on disk
+      const { stdout, stderr } = await execFileAsync(
+        process.execPath,
+        [INSTALLER_PATH],
+        { timeout: 30_000, windowsHide: true, maxBuffer: 1024 * 1024 },
+      );
+      if (probeBundle().current) {
+        ctx.ui.notify(
+          `pi-thinking-header: bundle patch ${migrating ? "migrated to" : "applied"} (${PATCH_VERSION}) at startup — ` +
+            "effective after the next restart; this session keeps its current renderer.",
+          "info",
+        );
+      } else {
+        const out = (stdout + "\n" + stderr).trim();
+        ctx.ui.notify(
+          "pi-thinking-header: startup auto-patch had no effect.\n" +
+            (out || "(no installer output)") +
+            "\nRun /thinking-header patch for details.",
+          "warning",
+        );
+      }
+    } catch (err) {
+      const detail = [err?.message, err?.stdout, err?.stderr].filter(Boolean).join("\n");
+      ctx.ui.notify(
+        "pi-thinking-header: startup auto-patch failed.\n" +
+          detail +
+          "\nRun /thinking-header patch to apply manually.",
+        "warning",
+      );
+    }
+  });
+}
+
 export default function (pi) {
   // /thinking-header — single entry point for everything this package does:
   //   /thinking-header                    status overview + usage
   //   /thinking-header patch              apply/repair the full-mode bundle patch
+  //   /thinking-header autopatch on|off   startup auto-check+apply (default on)
   //   /thinking-header decimals           show the k-token decimal places
   //   /thinking-header decimals <0-6>     set + persist them (0-6, default 2)
   // Registered in BOTH modes. Fallback mode re-reads the config per label; the
@@ -223,21 +295,38 @@ export default function (pi) {
     "usage:\n" +
     "  /thinking-header                    status overview\n" +
     "  /thinking-header patch              apply/repair the full-mode patch\n" +
+    "  /thinking-header autopatch on|off   startup auto-check+apply (default on)\n" +
     "  /thinking-header decimals           show k-token decimal places\n" +
     "  /thinking-header decimals <0-6>     set them (persisted, applies live)";
 
   pi.registerCommand("thinking-header", {
-    description:
-      "pi-thinking-header: status / `patch` apply-repair full-mode patch / `decimals <0-6>` token-count decimals",
+    description: "Thinking display settings: status, patch, autopatch, decimals",
     getArgumentCompletions: (prefix) => {
       const p = (prefix ?? "").trimStart();
-      if (p.includes(" ")) return null;
-      const items = [
-        { value: "patch", label: "apply/repair the full-mode bundle patch" },
-        { value: "decimals", label: "k-token decimal places (0-6, default 2)" },
-      ];
-      const filtered = items.filter((i) => i.value.startsWith(p));
-      return filtered.length > 0 ? filtered : null;
+      const tokens = p.split(/\s+/);
+      // Fully typed token → close the menu so Enter SUBMITS the command:
+      // pi's editor consumes Enter to accept an open completion (argument
+      // prefixes don't start with "/", so accept-without-submit applies), and
+      // an exact-match item would re-open the menu on every re-query — Enter
+      // would be swallowed repeatedly and the command would never run.
+      if (tokens.length === 1) {
+        const items = [
+          { value: "patch", label: "apply/repair the full-mode bundle patch" },
+          { value: "autopatch", label: "startup auto-apply/migrate the patch (on/off)" },
+          { value: "decimals", label: "k-token decimal places (0-6, default 2)" },
+        ];
+        const filtered = items.filter((i) => i.value.startsWith(tokens[0]));
+        if (filtered.length === 0) return null;
+        if (filtered.length === 1 && filtered[0].value === tokens[0]) return null;
+        return filtered;
+      }
+      if (tokens.length === 2 && tokens[0] === "autopatch") {
+        const opts = ["on", "off"].filter((o) => o.startsWith(tokens[1]));
+        if (opts.length === 0) return null;
+        if (opts.length === 1 && opts[0] === tokens[1]) return null;
+        return opts.map((o) => ({ value: o, label: `startup auto-patch: ${o}` }));
+      }
+      return null; // decimals <0-6>: single-digit values never need completion
     },
     handler: async (args, ctx) => {
       const argv = (args ?? "").trim().split(/\s+/).filter(Boolean);
@@ -260,7 +349,7 @@ export default function (pi) {
           return;
         }
         try {
-          saveDecimals(n);
+          saveConfigKey("decimals", n);
         } catch (err) {
           ctx.ui.notify(`pi-thinking-header: failed to save ${CONFIG_PATH}: ${err?.message ?? err}`, "error");
           return;
@@ -273,6 +362,42 @@ export default function (pi) {
         return;
       }
 
+      // ---- autopatch subcommand: startup auto-check+apply toggle --------
+      if (argv[0] === "autopatch") {
+        const raw = argv[1];
+        if (raw === undefined) {
+          ctx.ui.notify(
+            `pi-thinking-header: autoPatch = ${getAutoPatch() ? "on" : "off"} (default on)\n` +
+              "session-start check: applies the patch when missing, migrates old versions\n" +
+              `config: ${CONFIG_PATH}\n` +
+              "usage: /thinking-header autopatch on|off",
+            "info",
+          );
+          return;
+        }
+        if (raw !== "on" && raw !== "off") {
+          ctx.ui.notify('pi-thinking-header: autopatch expects "on" or "off"', "error");
+          return;
+        }
+        try {
+          saveConfigKey("autoPatch", raw === "on");
+        } catch (err) {
+          ctx.ui.notify(
+            `pi-thinking-header: failed to save ${CONFIG_PATH}: ${err?.message ?? err}`,
+            "error",
+          );
+          return;
+        }
+        ctx.ui.notify(
+          `pi-thinking-header: autoPatch = ${raw} → saved to ${CONFIG_PATH}\n` +
+            (raw === "on"
+              ? "the next session start applies/migrates the patch automatically"
+              : "startup auto-patch disabled — use /thinking-header patch to apply manually"),
+          "info",
+        );
+        return;
+      }
+
       // ---- patch subcommand: apply/repair the full-mode bundle patch ----
       if (argv[0] === "patch") {
         try {
@@ -284,9 +409,9 @@ export default function (pi) {
             );
             return;
           }
-          if (state.patched) {
+          if (state.current) {
             ctx.ui.notify(
-              `pi-thinking-header: full-mode patch already applied (v3.3) — decimals = ${getDecimals()}`,
+              `pi-thinking-header: full-mode patch already applied (${PATCH_VERSION}) — decimals = ${getDecimals()}`,
               "info",
             );
             return;
@@ -322,12 +447,15 @@ export default function (pi) {
       const state = probeBundle();
       const mode = !state.found
         ? "fallback (pi installation not detected)"
-        : state.patched
-          ? "full (bundle patch v3.3 applied)"
-          : "fallback (bundle unpatched — /thinking-header patch enables full mode)";
+        : state.current
+          ? `full (bundle patch ${PATCH_VERSION} applied)`
+          : state.patched
+            ? "full (older patch on disk — auto-migrates at next session start, or /thinking-header patch now)"
+            : "fallback (bundle unpatched — auto-patches at next session start, or /thinking-header patch now)";
       ctx.ui.notify(
         "pi-thinking-header\n" +
           `mode: ${mode}\n` +
+          `autoPatch: ${getAutoPatch() ? "on" : "off"} (default on)\n` +
           `decimals: ${getDecimals()} (default ${DEFAULT_DECIMALS})\n` +
           `config: ${CONFIG_PATH}\n` +
           usage,
@@ -337,10 +465,21 @@ export default function (pi) {
   });
 
   const bundle = probeBundle();
+  if (bundle.found && bundle.current) {
+    // FULL MODE, up to date: the bundle patch owns rendering end-to-end
+    // (per-message labels, width-aware single-line previews). Stay inert — a
+    // global label update here would corrupt the patch's per-block counts.
+    return;
+  }
+
+  // Not current on disk (unpatched, or an older family version): register the
+  // startup auto-patch. It lands on disk for the NEXT restart; this session
+  // keeps whichever renderer it booted with.
+  registerAutoPatch(pi);
+
   if (bundle.found && bundle.patched) {
-    // FULL MODE: the bundle patch owns rendering end-to-end (per-message labels,
-    // width-aware single-line previews). Stay inert — a global label update here
-    // would corrupt the patch's per-block counts.
+    // An older family patch still owns rendering for THIS session → stay
+    // inert to avoid double headers; the auto-patch migrates it (above).
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-thinking-header",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "dsh-style thinking display for pi: one-line header with token count (configurable decimals, default 2); collapsed thinking shows a single-line content preview",
   "keywords": [
     "pi-package",