pybao-cli 1.4.13 → 1.4.14

package/dist/{chunk-2PC7UK66.js → chunk-HPLN5FUH.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-RQVLBMP7.js";
 import {
   debug
-} from "./chunk-VGDDQSCO.js";
+} from "./chunk-O6YOHBUT.js";
 import {
   getCwd,
   getGlobalConfigFilePath,
   getLegacyGlobalConfigFilePath,
   logError
-} from "./chunk-P7MPKAPW.js";
+} from "./chunk-RNRRWM2A.js";
 
 // src/core/config/schema.ts
 function isAutoUpdaterStatus(value) {
@@ -688,7 +688,7 @@ function setModelPointer(pointer, modelName) {
     }
   };
   saveGlobalConfig(updatedConfig);
-  import("./model-YOPR5KUS.js").then(({ reloadModelManager }) => {
+  import("./model-RGNG5GUY.js").then(({ reloadModelManager }) => {
     reloadModelManager();
   });
 }

package/dist/{chunk-PHKBTCLT.js → chunk-IN2XQ6AY.js}

@@ -6,12 +6,12 @@ import {
 } from "./chunk-ERMQRV55.js";
 import {
   getGlobalConfig
-} from "./chunk-2PC7UK66.js";
+} from "./chunk-HPLN5FUH.js";
 import {
   debug,
   getCurrentRequest,
   logAPIError
-} from "./chunk-VGDDQSCO.js";
+} from "./chunk-O6YOHBUT.js";
 
 // src/services/ai/openai.ts
 import { ProxyAgent, fetch } from "undici";

package/dist/{chunk-Y3UMGUVE.js → chunk-KVPLJHUD.js}

@@ -5,7 +5,7 @@ import {
   getCwd,
   resolveXdgCachePath,
   resolveXdgDataPath
-} from "./chunk-P7MPKAPW.js";
+} from "./chunk-RNRRWM2A.js";
 
 // src/services/plugins/skillMarketplace.ts
 import {

package/dist/{chunk-CVJLF2VG.js → chunk-L2W6O75K.js}

@@ -4,16 +4,16 @@ import {
   LspServerRegistry,
   findNearestRoot,
   getInstallNotices
-} from "./chunk-5WXWY6LV.js";
+} from "./chunk-346SFBDV.js";
 import {
   levenshtein
 } from "./chunk-UZ34JEUK.js";
 import {
   debug
-} from "./chunk-VGDDQSCO.js";
+} from "./chunk-O6YOHBUT.js";
 import {
   getCwd
-} from "./chunk-P7MPKAPW.js";
+} from "./chunk-RNRRWM2A.js";
 
 // src/lsp/index.ts
 import { extname as extname2 } from "path";
@@ -27,6 +27,25 @@ import { createMessageConnection, StreamMessageReader, StreamMessageWriter } fro
 import { spawn } from "child_process";
 import { pathToFileURL, fileURLToPath } from "url";
 import { EventEmitter } from "events";
+function resolveInitTimeoutMs() {
+  const override = Number.parseInt(process.env.PYB_LSP_INIT_TIMEOUT_MS ?? "", 10);
+  if (Number.isFinite(override) && override > 0) return override;
+  return 1e4;
+}
+function withTimeout(promise, timeoutMs, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(message));
+    }, timeoutMs);
+    promise.then((result) => {
+      clearTimeout(timer);
+      resolve(result);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
 var DiagnosticsEventBus = class {
   debounceMs;
   lastEventAt = /* @__PURE__ */ new Map();
@@ -214,7 +233,12 @@ var GenericLspClient = class {
     if (this.initializationOptions && Object.keys(this.initializationOptions).length > 0) {
       params.initializationOptions = this.initializationOptions;
     }
-    const result = await this.connection.sendRequest("initialize", params);
+    const timeoutMs = resolveInitTimeoutMs();
+    const result = await withTimeout(
+      this.connection.sendRequest("initialize", params),
+      timeoutMs,
+      `LSP initialize timeout after ${timeoutMs}ms`
+    );
     await this.connection.sendNotification("initialized", {});
     await this.connection.sendNotification("workspace/didChangeConfiguration", {
       settings: { yaml: { schemaStore: { enable: false }, schemas: {} } }
@@ -225,12 +249,20 @@ var GenericLspClient = class {
   }
   async shutdown() {
     try {
-      await this.connection.sendRequest("shutdown");
-      await this.connection.sendNotification("exit");
+      if (this.connection) {
+        await this.connection.sendRequest("shutdown");
+        await this.connection.sendNotification("exit");
+      }
     } catch (error) {
     }
-    this.connection.dispose();
-    this.process.kill();
+    try {
+      this.connection?.dispose();
+    } catch {
+    }
+    try {
+      this.process?.kill();
+    } catch {
+    }
   }
   async goToDefinition(filePath, line, character) {
     const params = {
@@ -288,12 +320,12 @@ var GenericLspClient = class {
     const params = { item };
     return this.connection.sendRequest("callHierarchy/outgoingCalls", params);
   }
-  async didOpen(filePath, content, languageId) {
+  async didOpen(filePath, content, languageId, version = 1) {
     const params = {
       textDocument: {
         uri: this.normalizeUri(filePath),
         languageId,
-        version: 1,
+        version,
         text: content
       }
     };
@@ -324,11 +356,8 @@ var GenericLspClient = class {
       done = true;
     });
     await this.diagnosticsBus.waitForIdle(normalizedUri, timeoutMs);
-    if (done) {
-      unsubscribe();
-    } else {
-      unsubscribe();
-    }
+    unsubscribe();
+    return done;
   }
   on(event, handler) {
     this.diagnosticEvents.on(event, handler);
@@ -392,6 +421,7 @@ var LspClientManager = class _LspClientManager {
   requestMetrics = /* @__PURE__ */ new Map();
   compareSamples = /* @__PURE__ */ new Map();
   qualitySamples = /* @__PURE__ */ new Map();
+  fileVersions = /* @__PURE__ */ new Map();
   constructor() {
   }
   static getInstance() {
@@ -534,7 +564,7 @@ var LspClientManager = class _LspClientManager {
     const safeCwd = /[^\x00-\x7F]/.test(resolvedRoot) ? process.cwd() : resolvedRoot;
     let initOpts = serverInfo.initializationOptions;
     if (serverInfo.id === "pyright" || serverInfo.id === "ty") {
-      const { detectPythonVenv } = await import("./registry-KVMGHJ4N.js");
+      const { detectPythonVenv } = await import("./registry-5DE5QZMI.js");
       const pythonPath = detectPythonVenv(resolvedRoot);
       if (pythonPath) {
         initOpts = { ...initOpts ?? {}, pythonPath };
@@ -572,10 +602,12 @@ var LspClientManager = class _LspClientManager {
     this.requestMetrics.clear();
     this.compareSamples.clear();
     this.qualitySamples.clear();
+    this.fileVersions.clear();
   }
   async workspaceSymbol(query, rootPath = getCwd(), options) {
+    await this.maybeEnsureWorkspaceClients(rootPath);
     if (this.clients.size === 0) {
-      await this.maybeEnsureWorkspaceClients(rootPath);
+      await this.ensureWorkspaceClients(rootPath);
     }
     const results = [];
     for (const client of this.clients.values()) {
@@ -700,17 +732,18 @@ var LspClientManager = class _LspClientManager {
     return filtered;
   }
   async documentSymbol(filePath, rootPath = getCwd()) {
-    const client = await this.getClient(filePath, rootPath);
-    if (!client) {
-      return null;
-    }
     try {
-      const content = await readFile(filePath, "utf-8");
-      const ext = extname(filePath);
-      const serverInfo = LspServerRegistry.getInstance().getServerForExtension(ext);
-      const languageId = this.getLanguageId(ext, serverInfo ?? void 0);
-      await client.didOpen(filePath, content, languageId);
-      await client.waitForReadiness(filePath, 2e3);
+      const touched = await this.touchFile(filePath, rootPath, {
+        wait: true,
+        timeoutMs: 2e3
+      });
+      if (!touched) {
+        return null;
+      }
+      const client = await this.getClient(filePath, rootPath);
+      if (!client) {
+        return null;
+      }
       const symbols = await client.documentSymbol(filePath);
       return Array.isArray(symbols) ? symbols : [];
     } catch (e) {
@@ -927,9 +960,54 @@ var LspClientManager = class _LspClientManager {
   async waitForReadiness(filePath, rootPath = getCwd(), timeoutMs = 2e3) {
     const client = await this.getClientForFile(filePath);
     if (client) {
-      await client.waitForReadiness(filePath, timeoutMs);
-      this.readiness.set(filePath, this.now());
+      const ready = await client.waitForReadiness(filePath, timeoutMs);
+      if (ready) {
+        this.readiness.set(filePath, this.now());
+      }
+      return ready;
+    }
+    return false;
+  }
+  resolveServerInfoForClient(ext, client) {
+    const serverId = client.serverId;
+    const servers = LspServerRegistry.getInstance().getServersForExtension(ext);
+    if (serverId) {
+      const match = servers.find((server) => server.id === serverId);
+      if (match) return match;
+    }
+    return LspServerRegistry.getInstance().getServerForExtension(ext) ?? servers[0];
+  }
+  getVersionKey(filePath, client) {
+    const serverKey = client.serverKey ?? client.serverId ?? "unknown";
+    return `${serverKey}::${filePath}`;
+  }
+  async touchFile(filePath, rootPath = getCwd(), options) {
+    const client = await this.getClient(filePath, rootPath);
+    if (!client) {
+      return false;
     }
+    const content = await readFile(filePath, "utf-8");
+    const ext = extname(filePath);
+    const serverInfo = this.resolveServerInfoForClient(ext, client);
+    const languageId = this.getLanguageId(ext, serverInfo ?? void 0);
+    const versionKey = this.getVersionKey(filePath, client);
+    const currentVersion = this.fileVersions.get(versionKey);
+    const waitPromise = options?.wait ? client.waitForReadiness(filePath, options.timeoutMs ?? 2e3) : null;
+    if (currentVersion === void 0) {
+      await client.didOpen(filePath, content, languageId, 0);
+      this.fileVersions.set(versionKey, 0);
+    } else {
+      const nextVersion = currentVersion + 1;
+      await client.didChange(filePath, content, nextVersion);
+      this.fileVersions.set(versionKey, nextVersion);
+    }
+    if (waitPromise) {
+      const ready = await waitPromise;
+      if (ready) {
+        this.readiness.set(filePath, this.now());
+      }
+    }
+    return true;
   }
   matchesServerFilters(filePath, serverInfo) {
     const normalizePath = (value) => value.replace(/\\/g, "/");
@@ -2335,9 +2413,6 @@ var ScopeAnalyzer = class {
 };
 
 // src/lsp/index.ts
-function getLanguageId(ext) {
-  return LspServerRegistry.getInstance().getLanguageIdForExtension(ext);
-}
 function normalizeUri(filePath) {
   let uri = pathToFileURL2(filePath).href;
   if (process.platform === "win32") {
@@ -2551,6 +2626,10 @@ function resolveDiagnosticsTtlMs() {
 function buildDiagnosticsCacheKey(filePath, rootPath) {
   return `${rootPath}::${filePath}`;
 }
+function clearDiagnosticsCache(filePath, rootPath) {
+  const key = buildDiagnosticsCacheKey(filePath, rootPath);
+  diagnosticsCache.delete(key);
+}
 function recordFastPathFailure(filePath, reason, now) {
   let perFile = fastPathFailures.get(filePath);
   if (!perFile) {
@@ -2722,7 +2801,7 @@ function shouldSkipFastPath(filePath, now) {
   }
   return null;
 }
-function withTimeout(promise, timeoutMs) {
+function withTimeout2(promise, timeoutMs) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       reject(new Error("Tree-sitter timeout"));
@@ -3151,10 +3230,19 @@ var LspAPI = {
             recordAttempt("diagnostics");
             const startedAt = Date.now();
             if (input.waitForDiagnostics) {
-              await client.waitForReadiness(
+              const timeoutMs = input.timeoutMs ?? 5e3;
+              const ready = await client.waitForReadiness(
                 input.filePath,
-                input.timeoutMs ?? 5e3
+                timeoutMs
               );
+              if (!ready) {
+                recordFailure("diagnostics", "timeout");
+                return {
+                  formatted: `Diagnostics timeout after ${timeoutMs}ms`,
+                  resultCount: 0,
+                  fileCount: 0
+                };
+              }
             }
             const diagnostics = client.getDiagnostics(input.filePath);
             recordSuccess("diagnostics", startedAt);
@@ -3331,15 +3419,12 @@ var LspAPI = {
     return Promise.all(inputs.map((input) => this.run(input)));
   },
   async touchFile(filePath, options = {}) {
-    const client = await LspClientManager.getInstance().getClientForFile(filePath);
-    if (!client) return false;
-    const content = await readFile4(filePath, "utf-8");
-    const languageId = getLanguageId(extname2(filePath));
-    await client.didOpen(filePath, content, languageId);
-    if (options.wait) {
-      await client.waitForReadiness(filePath, options.timeoutMs ?? 2e3);
-    }
-    return true;
+    const rootPath = options.rootPath ?? getCwd();
+    clearDiagnosticsCache(filePath, rootPath);
+    return LspClientManager.getInstance().touchFile(filePath, rootPath, {
+      wait: options.wait,
+      timeoutMs: options.timeoutMs
+    });
   },
   async diagnostics(filePath, rootPath) {
     const resolvedRoot = rootPath ?? getCwd();
@@ -3468,7 +3553,7 @@ var LspFacade = {
               }
               try {
                 const start = Date.now();
-                const symbols = await withTimeout(
+                const symbols = await withTimeout2(
                   TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
                   getFastPathTimeoutMs(input.filePath, contentLength)
                 );
@@ -3542,7 +3627,7 @@ var LspFacade = {
               }
               try {
                 const start = Date.now();
-                const symbols = await withTimeout(
+                const symbols = await withTimeout2(
                   TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
                   getFastPathTimeoutMs(input.filePath, contentLength)
                 );
@@ -3577,6 +3662,13 @@ var LspFacade = {
             }
           }
         }
+        if (fallbackReason) {
+          return LspAPI.run({
+            operation: "documentSymbol",
+            filePath: input.filePath,
+            rootPath
+          });
+        }
       } else {
         const lang = ParserRegistry.getLanguage(input.filePath);
         const now = Date.now();
@@ -3604,7 +3696,7 @@ var LspFacade = {
             }
             try {
               const start = Date.now();
-              const symbols = await withTimeout(
+              const symbols = await withTimeout2(
                 TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
                 getFastPathTimeoutMs(input.filePath, contentLength)
               );
@@ -3684,11 +3776,49 @@ var LspFacade = {
       }
     }
     if (input.operation !== "workspaceSymbol") {
-      await LspAPI.touchFile(input.filePath, {
-        wait: input.operation === "diagnostics" && input.waitForDiagnostics,
-        timeoutMs: input.timeoutMs,
-        rootPath
-      });
+      if (input.operation === "diagnostics") {
+        const timeoutMs = input.timeoutMs ?? 5e3;
+        const shouldWait = input.waitForDiagnostics ?? true;
+        const touched = await LspAPI.touchFile(input.filePath, {
+          wait: false,
+          timeoutMs,
+          rootPath
+        });
+        if (!touched) {
+          return {
+            formatted: `No LSP server available for file type: ${extname2(input.filePath)}`,
+            resultCount: 0,
+            fileCount: 0
+          };
+        }
+        if (shouldWait) {
+          const ready = await LspClientManager.getInstance().waitForReadiness(
+            input.filePath,
+            rootPath,
+            timeoutMs
+          );
+          if (!ready) {
+            return {
+              formatted: `Diagnostics timeout after ${timeoutMs}ms`,
+              resultCount: 0,
+              fileCount: 0
+            };
+          }
+        }
+      } else {
+        const touched = await LspAPI.touchFile(input.filePath, {
+          wait: false,
+          timeoutMs: input.timeoutMs,
+          rootPath
+        });
+        if (!touched) {
+          return {
+            formatted: `No LSP server available for file type: ${extname2(input.filePath)}`,
+            resultCount: 0,
+            fileCount: 0
+          };
+        }
+      }
     }
     if (input.operation === "workspaceSymbol") {
       const query = input.query ?? input.filePath;
@@ -3714,6 +3844,12 @@ var LspFacade = {
   async touchFile(filePath, options = {}) {
     return LspAPI.touchFile(filePath, options);
   },
+  async diagnostics(filePath, options) {
+    return LspAPI.diagnostics(filePath, options?.rootPath);
+  },
+  async documentSymbolRaw(filePath, rootPath) {
+    return LspAPI.documentSymbolRaw(filePath, rootPath);
+  },
   async diagnosticsPretty(filePath, options) {
     return LspAPI.diagnosticsPretty(filePath, options);
   },