@trim21/personal-pi-extensions 0.1.482 → 0.1.486

package/package.json

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

package/src/aft/tools.ts

@@ -16,9 +16,11 @@ import {
   coerceTargetParam,
   formatCallgraphSections,
   PLAIN_CALLGRAPH_THEME,
+  type StatusSnapshot,
 } from "@cortexkit/aft-bridge";
 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 { formatDisplayPath, formatSubtitlePath, resolvePathArg } from "../lib/path.js";
 import { type ToolPendant } from "../lib/pendant.js";
@@ -349,6 +351,78 @@ export function registerCallgraphTool(pi: ExtensionAPI, ctx: AftToolContext): vo
   });
 }
 
+/**
+ * 语义索引进度订阅：索引冷构建期间 Rust 侧每秒推送一次 status_changed 帧
+ * （status_debounce_loop），aft-bridge 广播给 subscribeStatus 监听器。搜索
+ * 请求阻塞等待索引就绪（最长 SEMANTIC_INDEX_WAIT_TIMEOUT_MS）时，把进度
+ * 经 onUpdate 流式显示给用户，而不是无声干等。
+ */
+
+/** `BinaryBridge.subscribeStatus` 的能力探测类型：AftProjectTransport 接口上未暴露。 */
+interface StatusSubscribableBridge {
+  subscribeStatus?(listener: (snapshot: StatusSnapshot) => void): () => void;
+}
+
+function subscribeBridgeStatus(
+  bridge: AftProjectTransport,
+  listener: (snapshot: StatusSnapshot) => void,
+): (() => void) | undefined {
+  const subscribable = bridge as AftProjectTransport & StatusSubscribableBridge;
+  if (typeof subscribable.subscribeStatus !== "function") {
+    return undefined;
+  }
+  return subscribable.subscribeStatus(listener);
+}
+
+/**
+ * Rust 侧 status 快照里语义索引构建进度（SemanticHealthComponentSnapshot 的
+ * Building 分支）。上游控制的 schema：只声明真正读取的字段，未声明键忽略。
+ */
+const semanticIndexProgressSchema = Type.Object({
+  status: Type.Literal("building"),
+  stage: Type.Optional(Type.String()),
+  embedded_chunks: Type.Optional(Type.Integer()),
+  total_chunks: Type.Optional(Type.Integer()),
+  current_batch: Type.Optional(Type.Integer()),
+  total_batches: Type.Optional(Type.Integer()),
+});
+
+type SemanticIndexProgress = Static<typeof semanticIndexProgressSchema>;
+
+/** status 快照 → 一行构建进度文本；非 Building 或形状不符返回 undefined（不显示）。 */
+export function formatSemanticIndexProgress(snapshot: StatusSnapshot): string | undefined {
+  const raw = snapshot.semantic_index;
+  if (raw === undefined) {
+    return undefined;
+  }
+  let progress: SemanticIndexProgress;
+  try {
+    progress = Value.Parse(semanticIndexProgressSchema, raw);
+  } catch {
+    return undefined;
+  }
+  const parts = [`语义索引构建中${progress.stage === undefined ? "" : ` (${progress.stage})`}`];
+  if (
+    progress.embedded_chunks !== undefined &&
+    progress.total_chunks !== undefined &&
+    progress.total_chunks > 0
+  ) {
+    const percent = Math.min(
+      100,
+      Math.round((progress.embedded_chunks / progress.total_chunks) * 100),
+    );
+    parts.push(`${progress.embedded_chunks}/${progress.total_chunks} chunks (${percent}%)`);
+  }
+  if (
+    progress.current_batch !== undefined &&
+    progress.total_batches !== undefined &&
+    progress.total_batches > 0
+  ) {
+    parts.push(`batch ${progress.current_batch}/${progress.total_batches}`);
+  }
+  return parts.join(" · ");
+}
+
 const SearchParams = Type.Object(
   {
     query: Type.String({
@@ -380,7 +454,7 @@ export function registerSearchTool(pi: ExtensionAPI, ctx: AftToolContext): void
     promptSnippet: "Search code by meaning or exact text",
     promptGuidelines: [SEARCH_PROMPT],
     parameters: SearchParams,
-    async execute(_id, params, _signal, _onUpdate, extCtx) {
+    async execute(_id, params, _signal, onUpdate, extCtx) {
       if (typeof params.query !== "string" || params.query.trim().length === 0) {
         throw new Error("'query' must be a non-empty string");
       }
@@ -390,13 +464,29 @@ export function registerSearchTool(pi: ExtensionAPI, ctx: AftToolContext): void
         includeTests: params.includeTests,
       });
 
-      const { text, response } = await callAftTool(bridgeFor(ctx), "search", rawArgs, extCtx, {
-        // 默认 search 传输超时仅 60s，会早于索引等待（600s）触发；覆盖为等待
-        // 上限 + 常规执行预算。超时只说明响应被挤掉而非 bridge 挂死，保留
-        // 常驻的语义索引/LSP 状态。
-        transportTimeoutMs: SEMANTIC_INDEX_WAIT_TIMEOUT_MS + 60_000,
-        keepBridgeOnTimeout: true,
-      });
+      const bridge = bridgeFor(ctx);
+      const stopProgress =
+        onUpdate === undefined
+          ? undefined
+          : subscribeBridgeStatus(bridge, (snapshot) => {
+              const text = formatSemanticIndexProgress(snapshot);
+              if (text !== undefined) {
+                onUpdate({ content: [{ type: "text", text }], details: undefined });
+              }
+            });
+      let response: Record<string, unknown>;
+      let text: string;
+      try {
+        ({ text, response } = await callAftTool(bridge, "search", rawArgs, extCtx, {
+          // 默认 search 传输超时仅 60s，会早于索引等待（600s）触发；覆盖为等待
+          // 上限 + 常规执行预算。超时只说明响应被挤掉而非 bridge 挂死，保留
+          // 常驻的语义索引/LSP 状态。
+          transportTimeoutMs: SEMANTIC_INDEX_WAIT_TIMEOUT_MS + 60_000,
+          keepBridgeOnTimeout: true,
+        }));
+      } finally {
+        stopProgress?.();
+      }
       const truncated = response.truncated === true;
       return {
         content: [{ type: "text", text }],