@trim21/personal-pi-extensions 0.1.514 → 0.1.517

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.514",
+  "version": "0.1.517",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/aft/bridge.ts

@@ -1,9 +1,9 @@
 /**
  * AFT bridge 管理：二进制解析、transport pool 生命周期、工具调用封装。
  *
- * 依赖 @cortexkit/aft-bridge（官方协议的 JS 客户端）：findBinary 的解析顺序是
- * 缓存 → npm 平台包（@cortexkit/aft-<platform>，随 npm 镜像分发，无运行时网络）
- * → PATH → cargo → GitHub release 兜底；内网部署只要保证平台包版本与
+ * 依赖 @cortexkit/aft-bridge（官方协议的 JS 客户端）：二进制解析由入口在
+ * session_start 用 findBinary 完成（缓存 → npm 平台包 → PATH → cargo →
+ * GitHub release 兜底），本模块只接收解析结果；内网部署只要保证平台包版本与
  * aft-bridge 锁一致就不会走到最后的网络下载。
  */
 
@@ -12,7 +12,6 @@ import {
   type AftTransportPool,
   type BridgeRequestOptions,
   createAftTransportPool,
-  findBinary,
   inlineUserConfigTier,
   readConfigTiers,
   resolveCortexKitConfigPaths,
@@ -25,6 +24,8 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SemanticRemote } from "./config.js";
 import { type AftLogger, createAftLogger } from "./logger.js";
 
+export { findBinary } from "@cortexkit/aft-bridge";
+
 /** Pi 会话 ID：Rust 侧用它做 session 作用域（undo/checkpoint），感知工具可留空。 */
 export function resolveSessionId(extCtx: ExtensionContext): string | undefined {
   const manager = (extCtx as unknown as { sessionManager?: { getSessionId?: () => string } })
@@ -33,22 +34,6 @@ export function resolveSessionId(extCtx: ExtensionContext): string | undefined {
   return typeof id === "string" && id.length > 0 ? id : undefined;
 }
 
-/**
- * 解析 aft 二进制；失败时抛出（调用方决定是否降级不注册工具）。
- * 不带版本参数：findBinary 内部用 @cortexkit/aft-bridge 自身版本作为匹配基准，
- * 与 npm 平台包（@cortexkit/aft-<platform>）精确对齐，避免手动读 package.json
- * （其 exports 不暴露 ./package.json）。
- */
-export async function resolveAftBinary(): Promise<string> {
-  const path = await findBinary();
-  if (!path) {
-    throw new Error(
-      "AFT binary not found. Install via npm platform package (@cortexkit/aft-<platform>), cargo install agent-file-tools, or place `aft` on PATH.",
-    );
-  }
-  return path;
-}
-
 export interface AftPool {
   pool: AftTransportPool;
   /** 当前项目根（process.cwd），供 bridge 查询。 */
@@ -65,10 +50,11 @@ export interface AftState {
 export async function createAftState(
   cwd: string,
   sessionId: string | undefined,
+  binaryPath: string,
   semantic?: SemanticRemote,
 ): Promise<AftState> {
   const logger = createAftLogger(sessionId);
-  const pool = await createAftPool(cwd, logger, semantic);
+  const pool = await createAftPool(cwd, logger, binaryPath, semantic);
   return { logger, pool };
 }
 
@@ -91,6 +77,7 @@ export const SEMANTIC_API_KEY_ENV = "AFT_SEMANTIC_API_KEY";
 
 /**
  * 创建 transport pool。每个项目根一个常驻 aft 进程，跨 session 共享。
+ * `binaryPath` 由入口在 session_start 解析好传入（含 auto-download 兜底）。
  *
  * `semantic` 决定 embedding 密钥如何送达子进程：aft 只从配置里读 `api_key_env`
  * 这个「变量名」，再自己 `env::var` 取值，所以提供值时必须连带把名字告诉它。
@@ -99,12 +86,12 @@ export const SEMANTIC_API_KEY_ENV = "AFT_SEMANTIC_API_KEY";
 export async function createAftPool(
   cwd: string,
   logger: AftLogger,
+  binaryPath: string,
   semantic?: SemanticRemote,
 ): Promise<AftPool> {
   // 必须在任何 bridge 代码运行前注册：不设 logger 时 aft-bridge 会把 child
   // stderr / 生命周期日志 fallback 到 console.error，raw 输出打进 pi 的 stderr 破坏 TUI。
   setActiveLogger(logger);
-  const binaryPath = await resolveAftBinary();
   const paths = resolveCortexKitConfigPaths(cwd);
   const childEnv: Record<string, string> = {
     // Rust 侧 semantic_search 在索引 Building 时阻塞等待构建完成

package/src/aft/index.ts

@@ -9,9 +9,11 @@
  * fastembed 后端不使用。
  *
  * bridge 状态（日志 + 常驻 aft 子进程）的生命周期跟 session 走：session_start
- * 时用当次 session id 创建（日志落在 tmp/{sessionId}/aft-plugin.log），
- * session_shutdown / 进程退出时释放。工具实现经 getState() 取状态，
- * session 未初始化时抛错。
+ * 时先解析 aft 二进制（含 GitHub release auto-download 兜底）——找不到就
+ * notify warning 且不注册任何 aft 工具，避免模型看到只会抛 "not initialized"
+ * 的死工具；找到则注册工具并创建 bridge 状态（日志落在
+ * tmp/{sessionId}/aft-plugin.log），session_shutdown / 进程退出时释放。
+ * 工具实现经 getState() 取状态。
  *
  * Usage:
  *   pi -e ./aft/index.ts
@@ -20,7 +22,7 @@
 import { resolveCortexKitConfigPaths } from "@cortexkit/aft-bridge";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-import { createAftState, resolveSessionId, shutdownAftPool } from "./bridge.js";
+import { createAftState, findBinary, resolveSessionId, shutdownAftPool } from "./bridge.js";
 import { loadAftConfig } from "./config.js";
 import {
   registerCallgraphTool,
@@ -37,12 +39,6 @@ export default function aftReadTools(pi: ExtensionAPI): void {
   // bridge 状态跟 session 生命周期走，作用域就是本工厂闭包，不落到模块级。
   let state: Awaited<ReturnType<typeof createAftState>> | null = null;
 
-  // 预热：提前解析二进制并拉起 bridge 子进程；失败直接抛给 pi（runner 捕获
-  // 后上报 ExtensionError），工具调用侧经 getState() 抛未初始化错误。
-  pi.on("session_start", async (_event, ctx) => {
-    state = await createAftState(cwd, resolveSessionId(ctx), cfg.semanticRemote);
-  });
-
   const getState = (): Awaited<ReturnType<typeof createAftState>> => {
     if (!state) {
       throw new Error(
@@ -53,22 +49,38 @@ export default function aftReadTools(pi: ExtensionAPI): void {
   };
 
   const toolCtx = { cwd, getState };
-  registerOutlineTool(pi, toolCtx);
-  registerZoomTool(pi, toolCtx);
-  registerCallgraphTool(pi, toolCtx);
-  if (cfg.semanticSearch) {
-    if (cfg.semanticRemote) {
-      registerSearchTool(pi, toolCtx);
-    } else {
-      // 只开了开关、没配外部 embedding 后端：与其静默不注册，不如说明缺什么。
-      pi.on("session_start", (_event, ctx) => {
+
+  // 工具注册延迟到 session_start：先确认二进制可用再决定注册面。pi 允许在
+  // session_start 里 registerTool（工具表按 name 覆盖，跨 session 重复注册幂等）。
+  pi.on("session_start", async (_event, ctx) => {
+    const binaryPath = await findBinary();
+    if (!binaryPath) {
+      ctx.ui.notify(
+        "AFT binary not found: aft_outline / aft_zoom / aft_callgraph are not registered. " +
+          "Install the npm platform package (@cortexkit/aft-<platform>), run `cargo install agent-file-tools`, " +
+          "or place `aft` on PATH, then restart pi.",
+        "warning",
+      );
+      return;
+    }
+
+    registerOutlineTool(pi, toolCtx);
+    registerZoomTool(pi, toolCtx);
+    registerCallgraphTool(pi, toolCtx);
+    if (cfg.semanticSearch) {
+      if (cfg.semanticRemote) {
+        registerSearchTool(pi, toolCtx);
+      } else {
+        // 只开了开关、没配外部 embedding 后端：与其静默不注册，不如说明缺什么。
         ctx.ui.notify(
           "aft_search is not registered: semantic_search needs an external embedding backend (aft.jsonc semantic.backend = openai_compatible | ollama, plus base_url). The local ONNX fastembed default is not used here.",
           "warning",
         );
-      });
+      }
     }
-  }
+
+    state = await createAftState(cwd, resolveSessionId(ctx), binaryPath, cfg.semanticRemote);
+  });
 
   // 释放当前 session 的 bridge 状态。session_shutdown 是 pi 的正常生命周期；
   // beforeExit 兜底进程自然退出（不能注册 SIGINT/SIGTERM——那会吞掉 pi 主进程

package/src/gh-readonly.ts

@@ -35,7 +35,7 @@ import { homedir } from "node:os";
 import { delimiter, dirname, join, resolve } from "node:path";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 
 import { createGithubSearch, type GithubSearch, renderHits } from "./lib/github.js";
@@ -266,6 +266,23 @@ const workflowRunSchema = Type.Object({
 
 const workflowRunsSchema = Type.Object({ workflow_runs: Type.Array(workflowRunSchema) });
 
+/**
+ * One entry of `gh pr checks --json`. In JSON mode gh exits 0 once it could
+ * fetch the checks (real errors still exit non-zero); pass/fail/pending is
+ * only conveyed by the `bucket` field, never by the exit code.
+ */
+const prCheckSchema = Type.Object({
+  name: Type.String(),
+  state: Type.String(),
+  bucket: Type.String(),
+  startedAt: Type.Union([Type.String(), Type.Null()]),
+  completedAt: Type.Union([Type.String(), Type.Null()]),
+  link: Type.Union([Type.String(), Type.Null()]),
+  workflow: Type.Union([Type.String(), Type.Null()]),
+});
+
+type PrCheck = Static<typeof prCheckSchema>;
+
 function truncate(
   text: string,
   maxLines = 2000,
@@ -1111,6 +1128,174 @@ export async function writeLogFile(
   };
 }
 
+// ── pr checks watch (pure rendering + poll loop) ────────────────────────────
+
+const PR_CHECKS_JSON_FIELDS = "name,state,bucket,startedAt,completedAt,link,workflow";
+const CHECKS_POLL_INTERVAL_MS = 30_000;
+const CHECKS_WATCH_DEADLINE_MS = 600_000;
+
+function bucketIcon(bucket: string): string {
+  switch (bucket) {
+    case "pass": {
+      return "✅";
+    }
+    case "fail": {
+      return "❌";
+    }
+    case "skipping": {
+      return "⏭️";
+    }
+    case "cancel": {
+      return "🚫";
+    }
+    default: {
+      return "🔄";
+    }
+  }
+}
+
+function formatClock(ms: number): string {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()]
+    .map((n) => String(n).padStart(2, "0"))
+    .join(":");
+}
+
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+function formatDuration(totalSeconds: number): string {
+  const seconds = Math.floor(totalSeconds);
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = seconds % 60;
+  if (h > 0) return `${h}h${pad2(m)}m${pad2(s)}s`;
+  if (m > 0) return `${m}m${pad2(s)}s`;
+  return `${s}s`;
+}
+
+/**
+ * Render one polling round of `gh pr checks` like the GitHub web UI: check
+ * name, workflow, status, start time and elapsed (total duration when the
+ * check completed, time-so-far while still pending). Pure — no network.
+ */
+export function renderPrChecksTable(options: {
+  prNumber: number | string;
+  round: number;
+  checks: readonly PrCheck[];
+  now: number;
+}): string {
+  const { prNumber, round, checks, now } = options;
+  const completed = checks.filter((c) => c.bucket !== "pending").length;
+
+  const rows = checks.map((check) => {
+    const name = check.link ? `[${check.name}](${check.link})` : check.name;
+    let elapsed = "—";
+    if (check.startedAt) {
+      const startMs = Date.parse(check.startedAt);
+      const endMs = check.completedAt ? Date.parse(check.completedAt) : now;
+      elapsed = formatDuration(Math.max(0, (endMs - startMs) / 1000));
+    }
+    const cells = [
+      `${bucketIcon(check.bucket)} ${name}`,
+      check.workflow ?? "—",
+      check.bucket,
+      check.startedAt ? formatClock(Date.parse(check.startedAt)) : "—",
+      elapsed,
+    ];
+    return `| ${cells.join(" | ")} |`;
+  });
+  const body = rows.length > 0 ? rows.join("\n") : "| _no checks reported_ | — | — | — | — |";
+
+  return (
+    `### PR #${prNumber} checks — round ${round}: ${completed}/${checks.length} complete\n\n` +
+    `| Check | Workflow | Status | Started | Elapsed |\n` +
+    `|---|---|---|---|---|\n` +
+    body
+  );
+}
+
+function sleepInterruptibly(ms: number, signal: AbortSignal | undefined): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted while waiting for the next checks poll"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export interface PollPrChecksOptions {
+  prNumber: number | string;
+  repo?: string;
+  failFast: boolean;
+  cwd?: string;
+  signal?: AbortSignal;
+  /** Test overrides. */
+  intervalMs?: number;
+  deadlineMs?: number;
+  onUpdate?: (msg: CiLogsResult) => void;
+}
+
+/**
+ * Poll `gh pr checks --json` until no check is pending (or a fail-fast
+ * failure, or the deadline), emitting a GitHub-UI-like table via `onUpdate`
+ * each round. In JSON mode gh exits 0 whenever it could fetch the checks —
+ * completion is judged from the `bucket` field, not the exit code. A non-zero
+ * exit (no checks reported, auth, network) is not fatal here: the caller
+ * proceeds to the Actions API verification, which either produces the final
+ * report or surfaces the error.
+ */
+export async function pollPrChecks(options: PollPrChecksOptions): Promise<void> {
+  const { prNumber, repo, failFast, cwd, signal, onUpdate } = options;
+  const intervalMs = options.intervalMs ?? CHECKS_POLL_INTERVAL_MS;
+  const deadlineMs = options.deadlineMs ?? CHECKS_WATCH_DEADLINE_MS;
+  const args = [
+    "pr",
+    "checks",
+    String(prNumber),
+    ...repoArgs(repo),
+    "--json",
+    PR_CHECKS_JSON_FIELDS,
+  ];
+
+  const watchStart = Date.now();
+  for (let round = 1; ; round++) {
+    const result = await runGh(args, { cwd, signal });
+    if (result.killed) {
+      throw new Error(
+        result.reason === "timeout" ? "gh pr checks poll timed out" : "gh pr checks was aborted",
+      );
+    }
+    if (result.code !== 0) {
+      return;
+    }
+    const checks: PrCheck[] = Value.Parse(Type.Array(prCheckSchema), JSON.parse(result.stdout));
+
+    onUpdate?.({
+      content: [
+        { type: "text", text: renderPrChecksTable({ prNumber, round, checks, now: Date.now() }) },
+      ],
+      details: {},
+    });
+
+    const hasPending = checks.some((c) => c.bucket === "pending");
+    if (!hasPending) return;
+    if (failFast && checks.some((c) => c.bucket === "fail")) return;
+    if (Date.now() - watchStart >= deadlineMs) return;
+    await sleepInterruptibly(intervalMs, signal);
+  }
+}
+
 // ── tools ────────────────────────────────────────────────────────────────────
 
 export default function ghReadonlyTools(pi: ExtensionAPI) {
@@ -1667,6 +1852,7 @@ export default function ghReadonlyTools(pi: ExtensionAPI) {
     label: "Watch GitHub PR Checks",
     description:
       "Watch CI status checks for a PR until they complete. Blocks until all checks finish or one fails. " +
+      "Each polling round streams a GitHub-UI-like check table (name, workflow, status, started, elapsed) via onUpdate. " +
       "Use this when you need to wait for CI to complete and see the final result.",
     promptSnippet: "Watch and wait for GitHub PR CI checks to complete",
     parameters: Type.Object({
@@ -1685,21 +1871,17 @@ export default function ghReadonlyTools(pi: ExtensionAPI) {
         details: {},
       });
 
-      const args = ["pr", "checks", String(number), ...repoArgs(repo), "--watch"];
-      if (fail_fast) args.push("--fail-fast");
-
-      // gh 的退出码语义不可靠：checks 失败时返回 exit 1（SilentError），挂起时
-      // 返回 exit 8（PendingError），且失败详情只在非结构化的 stdout 表格里。
-      // 因此 watch 退出后直接用 Actions API 抓取该 PR head 提交关联的所有
+      // 轮询 `gh pr checks --json`（每轮经 onUpdate 流式输出 GitHub Web UI 风格
+      // 的检查表），结束后再用 Actions API 抓取该 PR head 提交关联的所有
       // workflow job，以 job 的真实 conclusion 为准判断成功/失败。
-      const result = await runGh(args, { cwd: ctx.cwd, signal, timeout: 600_000 });
-      if (result.killed) {
-        throw new Error(
-          result.reason === "timeout"
-            ? "gh pr checks --watch timed out after 10 minutes"
-            : "gh pr checks --watch was aborted",
-        );
-      }
+      await pollPrChecks({
+        prNumber: number,
+        repo,
+        failFast: fail_fast === true,
+        cwd: ctx.cwd,
+        signal,
+        onUpdate,
+      });
 
       const effectiveRepo = await resolveRepo(repo, signal, ctx.cwd, params);
       const prOut = await ghExec(